package com.opentae.data.xb.examples;

import com.opentae.core.mybatis.SgExample;
import com.opentae.core.mybatis.example.EntityColumn;
import com.opentae.core.mybatis.example.EntityTable;
import com.opentae.core.mybatis.mapperhelper.EntityHelper;
import com.opentae.data.xb.beans.DaifaTrade;

import java.util.*;
public class DaifaTradeExample extends SgExample<DaifaTradeExample.Criteria> {
    public static final Class<DaifaTrade> beanClass = DaifaTrade.class;
    public static final EntityTable entityTable = EntityHelper.getEntityTable(beanClass);
    public static EntityColumn returnStatus;
    public static EntityColumn tradeDiscountFee;
    public static EntityColumn settingAccountsStatus;
    public static EntityColumn ggoodsTime;
    public static EntityColumn receiverPhone;
    public static EntityColumn receiverQq;
    public static EntityColumn isUserStore;
    public static EntityColumn sureTime;
    public static EntityColumn orderReceivingStatus;
    public static EntityColumn receiverZip;
    public static EntityColumn isExport;
    public static EntityColumn daifaType;
    public static EntityColumn sendTime;
    public static EntityColumn taobaoUserNick;
    public static EntityColumn tuiFeeWorker;
    public static EntityColumn barCodeKey;
    public static EntityColumn postFeeBuFlag;
    public static EntityColumn checkTime;
    public static EntityColumn tradeStatus;
    public static EntityColumn remark10;
    public static EntityColumn realPayMoney;
    public static EntityColumn receiverState;
    public static EntityColumn printGgoodsStatus;
    public static EntityColumn buyerTelephone;
    public static EntityColumn postFeeBu;
    public static EntityColumn tradeFee;
    public static EntityColumn sellerName;
    public static EntityColumn refundStatus;
    public static EntityColumn payPostId;
    public static EntityColumn isTbSend;
    public static EntityColumn excelUrl;
    public static EntityColumn returnGoodsReason;
    public static EntityColumn buyerWw;
    public static EntityColumn zdPostFeeBuWorder;
    public static EntityColumn buyerWx;
    public static EntityColumn postName;
    public static EntityColumn agreeSplit;
    public static EntityColumn bigCustFlag;
    public static EntityColumn cdkeyStatus;
    public static EntityColumn postFee;
    public static EntityColumn receiverMobile;
    public static EntityColumn buyerName;
    public static EntityColumn taobaoTid;
    public static EntityColumn DFTradeREMARK1;
    public static EntityColumn tuiFeeReason;
    public static EntityColumn createTime;
    public static EntityColumn returnPostCode;
    public static EntityColumn sendStatus;
    public static EntityColumn payTime;
    public static EntityColumn payWay;
    public static EntityColumn buyerId;
    public static EntityColumn atchingStatus;
    public static EntityColumn buyerQq;
    public static EntityColumn buyerRemark;
    public static EntityColumn sellerId;
    public static EntityColumn modifyTime;
    public static EntityColumn reqRefundTime;
    public static EntityColumn daifaFee;
    public static EntityColumn orderReceivingTime;
    public static EntityColumn notPayPost;
    public static EntityColumn lastDoTime;
    public static EntityColumn useVoucher;
    public static EntityColumn finishTime;
    public static EntityColumn useVoucherAmount;
    public static EntityColumn tuiFeeTime;
    public static EntityColumn moreTradeId;
    public static EntityColumn tradeCode;
    public static EntityColumn weight;
    public static EntityColumn postId;
    public static EntityColumn dfTradeId;
    public static EntityColumn receiverAddress;
    public static EntityColumn volume;
    public static EntityColumn agreeStoreService;
    public static EntityColumn remark9;
    public static EntityColumn remark8;
    public static EntityColumn returnGoodsStatus;
    public static EntityColumn remark5;
    public static EntityColumn remark4;
    public static EntityColumn postCode;
    public static EntityColumn remark7;
    public static EntityColumn changeStatus;
    public static EntityColumn remark6;
    public static EntityColumn remark1;
    public static EntityColumn remark3;
    public static EntityColumn remark2;
    public static EntityColumn tuiFee;
    public static EntityColumn stockoutStatus;
    public static EntityColumn payNo;
    public static EntityColumn zdPostFeeBuTime;
    public static EntityColumn outOfStockTime;
    public static EntityColumn orderQrcode;
    public static EntityColumn goodsNum;
    public static EntityColumn tbWriteLabelStatus;
    public static EntityColumn printExpressStatus;
    public static EntityColumn stockoutCycleStatus;
    public static EntityColumn receiverName;
    public static EntityColumn refundReason;
    public static EntityColumn money;
    public static EntityColumn totalFee;
    public static EntityColumn payStatus;
    static {
        Set<EntityColumn> columns = entityTable.getEntityClassColumns();
        Map<String, EntityColumn> listMap = new HashMap<>();
        for (EntityColumn column : columns) {
            listMap.put(column.getProperty(), column);
        }
        returnStatus = listMap.get("returnStatus");
        tradeDiscountFee = listMap.get("tradeDiscountFee");
        settingAccountsStatus = listMap.get("settingAccountsStatus");
        ggoodsTime = listMap.get("ggoodsTime");
        receiverPhone = listMap.get("receiverPhone");
        receiverQq = listMap.get("receiverQq");
        isUserStore = listMap.get("isUserStore");
        sureTime = listMap.get("sureTime");
        orderReceivingStatus = listMap.get("orderReceivingStatus");
        receiverZip = listMap.get("receiverZip");
        isExport = listMap.get("isExport");
        daifaType = listMap.get("daifaType");
        sendTime = listMap.get("sendTime");
        taobaoUserNick = listMap.get("taobaoUserNick");
        tuiFeeWorker = listMap.get("tuiFeeWorker");
        barCodeKey = listMap.get("barCodeKey");
        postFeeBuFlag = listMap.get("postFeeBuFlag");
        checkTime = listMap.get("checkTime");
        tradeStatus = listMap.get("tradeStatus");
        remark10 = listMap.get("remark10");
        realPayMoney = listMap.get("realPayMoney");
        receiverState = listMap.get("receiverState");
        printGgoodsStatus = listMap.get("printGgoodsStatus");
        buyerTelephone = listMap.get("buyerTelephone");
        postFeeBu = listMap.get("postFeeBu");
        tradeFee = listMap.get("tradeFee");
        sellerName = listMap.get("sellerName");
        refundStatus = listMap.get("refundStatus");
        payPostId = listMap.get("payPostId");
        isTbSend = listMap.get("isTbSend");
        excelUrl = listMap.get("excelUrl");
        returnGoodsReason = listMap.get("returnGoodsReason");
        buyerWw = listMap.get("buyerWw");
        zdPostFeeBuWorder = listMap.get("zdPostFeeBuWorder");
        buyerWx = listMap.get("buyerWx");
        postName = listMap.get("postName");
        agreeSplit = listMap.get("agreeSplit");
        bigCustFlag = listMap.get("bigCustFlag");
        cdkeyStatus = listMap.get("cdkeyStatus");
        postFee = listMap.get("postFee");
        receiverMobile = listMap.get("receiverMobile");
        buyerName = listMap.get("buyerName");
        taobaoTid = listMap.get("taobaoTid");
        DFTradeREMARK1 = listMap.get("DFTradeREMARK1");
        tuiFeeReason = listMap.get("tuiFeeReason");
        createTime = listMap.get("createTime");
        returnPostCode = listMap.get("returnPostCode");
        sendStatus = listMap.get("sendStatus");
        payTime = listMap.get("payTime");
        payWay = listMap.get("payWay");
        buyerId = listMap.get("buyerId");
        atchingStatus = listMap.get("atchingStatus");
        buyerQq = listMap.get("buyerQq");
        buyerRemark = listMap.get("buyerRemark");
        sellerId = listMap.get("sellerId");
        modifyTime = listMap.get("modifyTime");
        reqRefundTime = listMap.get("reqRefundTime");
        daifaFee = listMap.get("daifaFee");
        orderReceivingTime = listMap.get("orderReceivingTime");
        notPayPost = listMap.get("notPayPost");
        lastDoTime = listMap.get("lastDoTime");
        useVoucher = listMap.get("useVoucher");
        finishTime = listMap.get("finishTime");
        useVoucherAmount = listMap.get("useVoucherAmount");
        tuiFeeTime = listMap.get("tuiFeeTime");
        moreTradeId = listMap.get("moreTradeId");
        tradeCode = listMap.get("tradeCode");
        weight = listMap.get("weight");
        postId = listMap.get("postId");
        dfTradeId = listMap.get("dfTradeId");
        receiverAddress = listMap.get("receiverAddress");
        volume = listMap.get("volume");
        agreeStoreService = listMap.get("agreeStoreService");
        remark9 = listMap.get("remark9");
        remark8 = listMap.get("remark8");
        returnGoodsStatus = listMap.get("returnGoodsStatus");
        remark5 = listMap.get("remark5");
        remark4 = listMap.get("remark4");
        postCode = listMap.get("postCode");
        remark7 = listMap.get("remark7");
        changeStatus = listMap.get("changeStatus");
        remark6 = listMap.get("remark6");
        remark1 = listMap.get("remark1");
        remark3 = listMap.get("remark3");
        remark2 = listMap.get("remark2");
        tuiFee = listMap.get("tuiFee");
        stockoutStatus = listMap.get("stockoutStatus");
        payNo = listMap.get("payNo");
        zdPostFeeBuTime = listMap.get("zdPostFeeBuTime");
        outOfStockTime = listMap.get("outOfStockTime");
        orderQrcode = listMap.get("orderQrcode");
        goodsNum = listMap.get("goodsNum");
        tbWriteLabelStatus = listMap.get("tbWriteLabelStatus");
        printExpressStatus = listMap.get("printExpressStatus");
        stockoutCycleStatus = listMap.get("stockoutCycleStatus");
        receiverName = listMap.get("receiverName");
        refundReason = listMap.get("refundReason");
        money = listMap.get("money");
        totalFee = listMap.get("totalFee");
        payStatus = listMap.get("payStatus");
        }

    public DaifaTradeExample() {
        this.setTableAlias(entityTable.getName());
    }

    @Override
    public EntityTable getEntityTable() {
        return entityTable;
    }

    @Override
    protected DaifaTradeExample.Criteria createCriteriaInternal() {
        return new DaifaTradeExample.Criteria(this);
    }

    public static class Criteria extends SgExample.GeneratedCriteria<Criteria> {
        protected Criteria(SgExample example) {
            super(example);
        }

        public DaifaTradeExample.Criteria andReturnStatusIsNull() {
            return isNull(returnStatus);
        }

        public DaifaTradeExample.Criteria andReturnStatusIsNotNull() {
            return isNotNull(returnStatus);
        }

        public DaifaTradeExample.Criteria andReturnStatusEqualTo(Integer value) {
            return equalTo(returnStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnStatusNotEqualTo(Integer value) {
            return notEqualTo(returnStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnStatusGreaterThan(Integer value) {
            return greaterThan(returnStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(returnStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnStatusLessThan(Integer value) {
            return lessThan(returnStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(returnStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnStatusIn(List<Integer> values) {
            return in(returnStatus, values);
        }

        public DaifaTradeExample.Criteria andReturnStatusNotIn(List<Integer> values) {
            return notIn(returnStatus, values);
        }

        public DaifaTradeExample.Criteria andReturnStatusBetween(Integer value1, Integer value2) {
            return between(returnStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andReturnStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(returnStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andTradeDiscountFeeIsNull() {
            return isNull(tradeDiscountFee);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeIsNotNull() {
            return isNotNull(tradeDiscountFee);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeEqualTo(String value) {
            return equalTo(tradeDiscountFee, value);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeNotEqualTo(String value) {
            return notEqualTo(tradeDiscountFee, value);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeGreaterThan(String value) {
            return greaterThan(tradeDiscountFee, value);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(tradeDiscountFee, value);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeLessThan(String value) {
            return lessThan(tradeDiscountFee, value);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(tradeDiscountFee, value);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeLike(String value) {
            return like(tradeDiscountFee, value);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeNotLike(String value) {
            return notLike(tradeDiscountFee, value);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeIn(List<String> values) {
            return in(tradeDiscountFee, values);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeNotIn(List<String> values) {
            return notIn(tradeDiscountFee, values);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeBetween(String value1, String value2) {
            return between(tradeDiscountFee, value1, value2);
        }

        public DaifaTradeExample.Criteria andTradeDiscountFeeNotBetween(String value1, String value2) {
            return notBetween(tradeDiscountFee, value1, value2);
        }
        public DaifaTradeExample.Criteria andSettingAccountsStatusIsNull() {
            return isNull(settingAccountsStatus);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusIsNotNull() {
            return isNotNull(settingAccountsStatus);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusEqualTo(Integer value) {
            return equalTo(settingAccountsStatus, value);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusNotEqualTo(Integer value) {
            return notEqualTo(settingAccountsStatus, value);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusGreaterThan(Integer value) {
            return greaterThan(settingAccountsStatus, value);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(settingAccountsStatus, value);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusLessThan(Integer value) {
            return lessThan(settingAccountsStatus, value);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(settingAccountsStatus, value);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusIn(List<Integer> values) {
            return in(settingAccountsStatus, values);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusNotIn(List<Integer> values) {
            return notIn(settingAccountsStatus, values);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusBetween(Integer value1, Integer value2) {
            return between(settingAccountsStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andSettingAccountsStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(settingAccountsStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andGgoodsTimeIsNull() {
            return isNull(ggoodsTime);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeIsNotNull() {
            return isNotNull(ggoodsTime);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeEqualTo(Date value) {
            return equalTo(ggoodsTime, value);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeNotEqualTo(Date value) {
            return notEqualTo(ggoodsTime, value);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeGreaterThan(Date value) {
            return greaterThan(ggoodsTime, value);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(ggoodsTime, value);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeLessThan(Date value) {
            return lessThan(ggoodsTime, value);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(ggoodsTime, value);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeIn(List<Date> values) {
            return in(ggoodsTime, values);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeNotIn(List<Date> values) {
            return notIn(ggoodsTime, values);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeBetween(Date value1, Date value2) {
            return between(ggoodsTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andGgoodsTimeNotBetween(Date value1, Date value2) {
            return notBetween(ggoodsTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andReceiverPhoneIsNull() {
            return isNull(receiverPhone);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneIsNotNull() {
            return isNotNull(receiverPhone);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneEqualTo(String value) {
            return equalTo(receiverPhone, value);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneNotEqualTo(String value) {
            return notEqualTo(receiverPhone, value);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneGreaterThan(String value) {
            return greaterThan(receiverPhone, value);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(receiverPhone, value);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneLessThan(String value) {
            return lessThan(receiverPhone, value);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(receiverPhone, value);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneLike(String value) {
            return like(receiverPhone, value);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneNotLike(String value) {
            return notLike(receiverPhone, value);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneIn(List<String> values) {
            return in(receiverPhone, values);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneNotIn(List<String> values) {
            return notIn(receiverPhone, values);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneBetween(String value1, String value2) {
            return between(receiverPhone, value1, value2);
        }

        public DaifaTradeExample.Criteria andReceiverPhoneNotBetween(String value1, String value2) {
            return notBetween(receiverPhone, value1, value2);
        }
        public DaifaTradeExample.Criteria andReceiverQqIsNull() {
            return isNull(receiverQq);
        }

        public DaifaTradeExample.Criteria andReceiverQqIsNotNull() {
            return isNotNull(receiverQq);
        }

        public DaifaTradeExample.Criteria andReceiverQqEqualTo(String value) {
            return equalTo(receiverQq, value);
        }

        public DaifaTradeExample.Criteria andReceiverQqNotEqualTo(String value) {
            return notEqualTo(receiverQq, value);
        }

        public DaifaTradeExample.Criteria andReceiverQqGreaterThan(String value) {
            return greaterThan(receiverQq, value);
        }

        public DaifaTradeExample.Criteria andReceiverQqGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(receiverQq, value);
        }

        public DaifaTradeExample.Criteria andReceiverQqLessThan(String value) {
            return lessThan(receiverQq, value);
        }

        public DaifaTradeExample.Criteria andReceiverQqLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(receiverQq, value);
        }

        public DaifaTradeExample.Criteria andReceiverQqLike(String value) {
            return like(receiverQq, value);
        }

        public DaifaTradeExample.Criteria andReceiverQqNotLike(String value) {
            return notLike(receiverQq, value);
        }

        public DaifaTradeExample.Criteria andReceiverQqIn(List<String> values) {
            return in(receiverQq, values);
        }

        public DaifaTradeExample.Criteria andReceiverQqNotIn(List<String> values) {
            return notIn(receiverQq, values);
        }

        public DaifaTradeExample.Criteria andReceiverQqBetween(String value1, String value2) {
            return between(receiverQq, value1, value2);
        }

        public DaifaTradeExample.Criteria andReceiverQqNotBetween(String value1, String value2) {
            return notBetween(receiverQq, value1, value2);
        }
        public DaifaTradeExample.Criteria andIsUserStoreIsNull() {
            return isNull(isUserStore);
        }

        public DaifaTradeExample.Criteria andIsUserStoreIsNotNull() {
            return isNotNull(isUserStore);
        }

        public DaifaTradeExample.Criteria andIsUserStoreEqualTo(Integer value) {
            return equalTo(isUserStore, value);
        }

        public DaifaTradeExample.Criteria andIsUserStoreNotEqualTo(Integer value) {
            return notEqualTo(isUserStore, value);
        }

        public DaifaTradeExample.Criteria andIsUserStoreGreaterThan(Integer value) {
            return greaterThan(isUserStore, value);
        }

        public DaifaTradeExample.Criteria andIsUserStoreGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(isUserStore, value);
        }

        public DaifaTradeExample.Criteria andIsUserStoreLessThan(Integer value) {
            return lessThan(isUserStore, value);
        }

        public DaifaTradeExample.Criteria andIsUserStoreLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(isUserStore, value);
        }

        public DaifaTradeExample.Criteria andIsUserStoreIn(List<Integer> values) {
            return in(isUserStore, values);
        }

        public DaifaTradeExample.Criteria andIsUserStoreNotIn(List<Integer> values) {
            return notIn(isUserStore, values);
        }

        public DaifaTradeExample.Criteria andIsUserStoreBetween(Integer value1, Integer value2) {
            return between(isUserStore, value1, value2);
        }

        public DaifaTradeExample.Criteria andIsUserStoreNotBetween(Integer value1, Integer value2) {
            return notBetween(isUserStore, value1, value2);
        }
        public DaifaTradeExample.Criteria andSureTimeIsNull() {
            return isNull(sureTime);
        }

        public DaifaTradeExample.Criteria andSureTimeIsNotNull() {
            return isNotNull(sureTime);
        }

        public DaifaTradeExample.Criteria andSureTimeEqualTo(Date value) {
            return equalTo(sureTime, value);
        }

        public DaifaTradeExample.Criteria andSureTimeNotEqualTo(Date value) {
            return notEqualTo(sureTime, value);
        }

        public DaifaTradeExample.Criteria andSureTimeGreaterThan(Date value) {
            return greaterThan(sureTime, value);
        }

        public DaifaTradeExample.Criteria andSureTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(sureTime, value);
        }

        public DaifaTradeExample.Criteria andSureTimeLessThan(Date value) {
            return lessThan(sureTime, value);
        }

        public DaifaTradeExample.Criteria andSureTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(sureTime, value);
        }

        public DaifaTradeExample.Criteria andSureTimeIn(List<Date> values) {
            return in(sureTime, values);
        }

        public DaifaTradeExample.Criteria andSureTimeNotIn(List<Date> values) {
            return notIn(sureTime, values);
        }

        public DaifaTradeExample.Criteria andSureTimeBetween(Date value1, Date value2) {
            return between(sureTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andSureTimeNotBetween(Date value1, Date value2) {
            return notBetween(sureTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andOrderReceivingStatusIsNull() {
            return isNull(orderReceivingStatus);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusIsNotNull() {
            return isNotNull(orderReceivingStatus);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusEqualTo(Integer value) {
            return equalTo(orderReceivingStatus, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusNotEqualTo(Integer value) {
            return notEqualTo(orderReceivingStatus, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusGreaterThan(Integer value) {
            return greaterThan(orderReceivingStatus, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(orderReceivingStatus, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusLessThan(Integer value) {
            return lessThan(orderReceivingStatus, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(orderReceivingStatus, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusIn(List<Integer> values) {
            return in(orderReceivingStatus, values);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusNotIn(List<Integer> values) {
            return notIn(orderReceivingStatus, values);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusBetween(Integer value1, Integer value2) {
            return between(orderReceivingStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andOrderReceivingStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(orderReceivingStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andReceiverZipIsNull() {
            return isNull(receiverZip);
        }

        public DaifaTradeExample.Criteria andReceiverZipIsNotNull() {
            return isNotNull(receiverZip);
        }

        public DaifaTradeExample.Criteria andReceiverZipEqualTo(String value) {
            return equalTo(receiverZip, value);
        }

        public DaifaTradeExample.Criteria andReceiverZipNotEqualTo(String value) {
            return notEqualTo(receiverZip, value);
        }

        public DaifaTradeExample.Criteria andReceiverZipGreaterThan(String value) {
            return greaterThan(receiverZip, value);
        }

        public DaifaTradeExample.Criteria andReceiverZipGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(receiverZip, value);
        }

        public DaifaTradeExample.Criteria andReceiverZipLessThan(String value) {
            return lessThan(receiverZip, value);
        }

        public DaifaTradeExample.Criteria andReceiverZipLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(receiverZip, value);
        }

        public DaifaTradeExample.Criteria andReceiverZipLike(String value) {
            return like(receiverZip, value);
        }

        public DaifaTradeExample.Criteria andReceiverZipNotLike(String value) {
            return notLike(receiverZip, value);
        }

        public DaifaTradeExample.Criteria andReceiverZipIn(List<String> values) {
            return in(receiverZip, values);
        }

        public DaifaTradeExample.Criteria andReceiverZipNotIn(List<String> values) {
            return notIn(receiverZip, values);
        }

        public DaifaTradeExample.Criteria andReceiverZipBetween(String value1, String value2) {
            return between(receiverZip, value1, value2);
        }

        public DaifaTradeExample.Criteria andReceiverZipNotBetween(String value1, String value2) {
            return notBetween(receiverZip, value1, value2);
        }
        public DaifaTradeExample.Criteria andIsExportIsNull() {
            return isNull(isExport);
        }

        public DaifaTradeExample.Criteria andIsExportIsNotNull() {
            return isNotNull(isExport);
        }

        public DaifaTradeExample.Criteria andIsExportEqualTo(Integer value) {
            return equalTo(isExport, value);
        }

        public DaifaTradeExample.Criteria andIsExportNotEqualTo(Integer value) {
            return notEqualTo(isExport, value);
        }

        public DaifaTradeExample.Criteria andIsExportGreaterThan(Integer value) {
            return greaterThan(isExport, value);
        }

        public DaifaTradeExample.Criteria andIsExportGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(isExport, value);
        }

        public DaifaTradeExample.Criteria andIsExportLessThan(Integer value) {
            return lessThan(isExport, value);
        }

        public DaifaTradeExample.Criteria andIsExportLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(isExport, value);
        }

        public DaifaTradeExample.Criteria andIsExportIn(List<Integer> values) {
            return in(isExport, values);
        }

        public DaifaTradeExample.Criteria andIsExportNotIn(List<Integer> values) {
            return notIn(isExport, values);
        }

        public DaifaTradeExample.Criteria andIsExportBetween(Integer value1, Integer value2) {
            return between(isExport, value1, value2);
        }

        public DaifaTradeExample.Criteria andIsExportNotBetween(Integer value1, Integer value2) {
            return notBetween(isExport, value1, value2);
        }
        public DaifaTradeExample.Criteria andDaifaTypeIsNull() {
            return isNull(daifaType);
        }

        public DaifaTradeExample.Criteria andDaifaTypeIsNotNull() {
            return isNotNull(daifaType);
        }

        public DaifaTradeExample.Criteria andDaifaTypeEqualTo(Integer value) {
            return equalTo(daifaType, value);
        }

        public DaifaTradeExample.Criteria andDaifaTypeNotEqualTo(Integer value) {
            return notEqualTo(daifaType, value);
        }

        public DaifaTradeExample.Criteria andDaifaTypeGreaterThan(Integer value) {
            return greaterThan(daifaType, value);
        }

        public DaifaTradeExample.Criteria andDaifaTypeGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(daifaType, value);
        }

        public DaifaTradeExample.Criteria andDaifaTypeLessThan(Integer value) {
            return lessThan(daifaType, value);
        }

        public DaifaTradeExample.Criteria andDaifaTypeLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(daifaType, value);
        }

        public DaifaTradeExample.Criteria andDaifaTypeIn(List<Integer> values) {
            return in(daifaType, values);
        }

        public DaifaTradeExample.Criteria andDaifaTypeNotIn(List<Integer> values) {
            return notIn(daifaType, values);
        }

        public DaifaTradeExample.Criteria andDaifaTypeBetween(Integer value1, Integer value2) {
            return between(daifaType, value1, value2);
        }

        public DaifaTradeExample.Criteria andDaifaTypeNotBetween(Integer value1, Integer value2) {
            return notBetween(daifaType, value1, value2);
        }
        public DaifaTradeExample.Criteria andSendTimeIsNull() {
            return isNull(sendTime);
        }

        public DaifaTradeExample.Criteria andSendTimeIsNotNull() {
            return isNotNull(sendTime);
        }

        public DaifaTradeExample.Criteria andSendTimeEqualTo(Date value) {
            return equalTo(sendTime, value);
        }

        public DaifaTradeExample.Criteria andSendTimeNotEqualTo(Date value) {
            return notEqualTo(sendTime, value);
        }

        public DaifaTradeExample.Criteria andSendTimeGreaterThan(Date value) {
            return greaterThan(sendTime, value);
        }

        public DaifaTradeExample.Criteria andSendTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(sendTime, value);
        }

        public DaifaTradeExample.Criteria andSendTimeLessThan(Date value) {
            return lessThan(sendTime, value);
        }

        public DaifaTradeExample.Criteria andSendTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(sendTime, value);
        }

        public DaifaTradeExample.Criteria andSendTimeIn(List<Date> values) {
            return in(sendTime, values);
        }

        public DaifaTradeExample.Criteria andSendTimeNotIn(List<Date> values) {
            return notIn(sendTime, values);
        }

        public DaifaTradeExample.Criteria andSendTimeBetween(Date value1, Date value2) {
            return between(sendTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andSendTimeNotBetween(Date value1, Date value2) {
            return notBetween(sendTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andTaobaoUserNickIsNull() {
            return isNull(taobaoUserNick);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickIsNotNull() {
            return isNotNull(taobaoUserNick);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickEqualTo(String value) {
            return equalTo(taobaoUserNick, value);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickNotEqualTo(String value) {
            return notEqualTo(taobaoUserNick, value);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickGreaterThan(String value) {
            return greaterThan(taobaoUserNick, value);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(taobaoUserNick, value);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickLessThan(String value) {
            return lessThan(taobaoUserNick, value);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(taobaoUserNick, value);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickLike(String value) {
            return like(taobaoUserNick, value);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickNotLike(String value) {
            return notLike(taobaoUserNick, value);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickIn(List<String> values) {
            return in(taobaoUserNick, values);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickNotIn(List<String> values) {
            return notIn(taobaoUserNick, values);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickBetween(String value1, String value2) {
            return between(taobaoUserNick, value1, value2);
        }

        public DaifaTradeExample.Criteria andTaobaoUserNickNotBetween(String value1, String value2) {
            return notBetween(taobaoUserNick, value1, value2);
        }
        public DaifaTradeExample.Criteria andTuiFeeWorkerIsNull() {
            return isNull(tuiFeeWorker);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerIsNotNull() {
            return isNotNull(tuiFeeWorker);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerEqualTo(String value) {
            return equalTo(tuiFeeWorker, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerNotEqualTo(String value) {
            return notEqualTo(tuiFeeWorker, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerGreaterThan(String value) {
            return greaterThan(tuiFeeWorker, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(tuiFeeWorker, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerLessThan(String value) {
            return lessThan(tuiFeeWorker, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(tuiFeeWorker, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerLike(String value) {
            return like(tuiFeeWorker, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerNotLike(String value) {
            return notLike(tuiFeeWorker, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerIn(List<String> values) {
            return in(tuiFeeWorker, values);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerNotIn(List<String> values) {
            return notIn(tuiFeeWorker, values);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerBetween(String value1, String value2) {
            return between(tuiFeeWorker, value1, value2);
        }

        public DaifaTradeExample.Criteria andTuiFeeWorkerNotBetween(String value1, String value2) {
            return notBetween(tuiFeeWorker, value1, value2);
        }
        public DaifaTradeExample.Criteria andBarCodeKeyIsNull() {
            return isNull(barCodeKey);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyIsNotNull() {
            return isNotNull(barCodeKey);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyEqualTo(String value) {
            return equalTo(barCodeKey, value);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyNotEqualTo(String value) {
            return notEqualTo(barCodeKey, value);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyGreaterThan(String value) {
            return greaterThan(barCodeKey, value);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(barCodeKey, value);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyLessThan(String value) {
            return lessThan(barCodeKey, value);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(barCodeKey, value);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyLike(String value) {
            return like(barCodeKey, value);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyNotLike(String value) {
            return notLike(barCodeKey, value);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyIn(List<String> values) {
            return in(barCodeKey, values);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyNotIn(List<String> values) {
            return notIn(barCodeKey, values);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyBetween(String value1, String value2) {
            return between(barCodeKey, value1, value2);
        }

        public DaifaTradeExample.Criteria andBarCodeKeyNotBetween(String value1, String value2) {
            return notBetween(barCodeKey, value1, value2);
        }
        public DaifaTradeExample.Criteria andPostFeeBuFlagIsNull() {
            return isNull(postFeeBuFlag);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagIsNotNull() {
            return isNotNull(postFeeBuFlag);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagEqualTo(Integer value) {
            return equalTo(postFeeBuFlag, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagNotEqualTo(Integer value) {
            return notEqualTo(postFeeBuFlag, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagGreaterThan(Integer value) {
            return greaterThan(postFeeBuFlag, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(postFeeBuFlag, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagLessThan(Integer value) {
            return lessThan(postFeeBuFlag, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(postFeeBuFlag, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagIn(List<Integer> values) {
            return in(postFeeBuFlag, values);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagNotIn(List<Integer> values) {
            return notIn(postFeeBuFlag, values);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagBetween(Integer value1, Integer value2) {
            return between(postFeeBuFlag, value1, value2);
        }

        public DaifaTradeExample.Criteria andPostFeeBuFlagNotBetween(Integer value1, Integer value2) {
            return notBetween(postFeeBuFlag, value1, value2);
        }
        public DaifaTradeExample.Criteria andCheckTimeIsNull() {
            return isNull(checkTime);
        }

        public DaifaTradeExample.Criteria andCheckTimeIsNotNull() {
            return isNotNull(checkTime);
        }

        public DaifaTradeExample.Criteria andCheckTimeEqualTo(Date value) {
            return equalTo(checkTime, value);
        }

        public DaifaTradeExample.Criteria andCheckTimeNotEqualTo(Date value) {
            return notEqualTo(checkTime, value);
        }

        public DaifaTradeExample.Criteria andCheckTimeGreaterThan(Date value) {
            return greaterThan(checkTime, value);
        }

        public DaifaTradeExample.Criteria andCheckTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(checkTime, value);
        }

        public DaifaTradeExample.Criteria andCheckTimeLessThan(Date value) {
            return lessThan(checkTime, value);
        }

        public DaifaTradeExample.Criteria andCheckTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(checkTime, value);
        }

        public DaifaTradeExample.Criteria andCheckTimeIn(List<Date> values) {
            return in(checkTime, values);
        }

        public DaifaTradeExample.Criteria andCheckTimeNotIn(List<Date> values) {
            return notIn(checkTime, values);
        }

        public DaifaTradeExample.Criteria andCheckTimeBetween(Date value1, Date value2) {
            return between(checkTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andCheckTimeNotBetween(Date value1, Date value2) {
            return notBetween(checkTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andTradeStatusIsNull() {
            return isNull(tradeStatus);
        }

        public DaifaTradeExample.Criteria andTradeStatusIsNotNull() {
            return isNotNull(tradeStatus);
        }

        public DaifaTradeExample.Criteria andTradeStatusEqualTo(Integer value) {
            return equalTo(tradeStatus, value);
        }

        public DaifaTradeExample.Criteria andTradeStatusNotEqualTo(Integer value) {
            return notEqualTo(tradeStatus, value);
        }

        public DaifaTradeExample.Criteria andTradeStatusGreaterThan(Integer value) {
            return greaterThan(tradeStatus, value);
        }

        public DaifaTradeExample.Criteria andTradeStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(tradeStatus, value);
        }

        public DaifaTradeExample.Criteria andTradeStatusLessThan(Integer value) {
            return lessThan(tradeStatus, value);
        }

        public DaifaTradeExample.Criteria andTradeStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(tradeStatus, value);
        }

        public DaifaTradeExample.Criteria andTradeStatusIn(List<Integer> values) {
            return in(tradeStatus, values);
        }

        public DaifaTradeExample.Criteria andTradeStatusNotIn(List<Integer> values) {
            return notIn(tradeStatus, values);
        }

        public DaifaTradeExample.Criteria andTradeStatusBetween(Integer value1, Integer value2) {
            return between(tradeStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andTradeStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(tradeStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark10IsNull() {
            return isNull(remark10);
        }

        public DaifaTradeExample.Criteria andRemark10IsNotNull() {
            return isNotNull(remark10);
        }

        public DaifaTradeExample.Criteria andRemark10EqualTo(String value) {
            return equalTo(remark10, value);
        }

        public DaifaTradeExample.Criteria andRemark10NotEqualTo(String value) {
            return notEqualTo(remark10, value);
        }

        public DaifaTradeExample.Criteria andRemark10GreaterThan(String value) {
            return greaterThan(remark10, value);
        }

        public DaifaTradeExample.Criteria andRemark10GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark10, value);
        }

        public DaifaTradeExample.Criteria andRemark10LessThan(String value) {
            return lessThan(remark10, value);
        }

        public DaifaTradeExample.Criteria andRemark10LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark10, value);
        }

        public DaifaTradeExample.Criteria andRemark10Like(String value) {
            return like(remark10, value);
        }

        public DaifaTradeExample.Criteria andRemark10NotLike(String value) {
            return notLike(remark10, value);
        }

        public DaifaTradeExample.Criteria andRemark10In(List<String> values) {
            return in(remark10, values);
        }

        public DaifaTradeExample.Criteria andRemark10NotIn(List<String> values) {
            return notIn(remark10, values);
        }

        public DaifaTradeExample.Criteria andRemark10Between(String value1, String value2) {
            return between(remark10, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark10NotBetween(String value1, String value2) {
            return notBetween(remark10, value1, value2);
        }
        public DaifaTradeExample.Criteria andRealPayMoneyIsNull() {
            return isNull(realPayMoney);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyIsNotNull() {
            return isNotNull(realPayMoney);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyEqualTo(String value) {
            return equalTo(realPayMoney, value);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyNotEqualTo(String value) {
            return notEqualTo(realPayMoney, value);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyGreaterThan(String value) {
            return greaterThan(realPayMoney, value);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(realPayMoney, value);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyLessThan(String value) {
            return lessThan(realPayMoney, value);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(realPayMoney, value);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyLike(String value) {
            return like(realPayMoney, value);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyNotLike(String value) {
            return notLike(realPayMoney, value);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyIn(List<String> values) {
            return in(realPayMoney, values);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyNotIn(List<String> values) {
            return notIn(realPayMoney, values);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyBetween(String value1, String value2) {
            return between(realPayMoney, value1, value2);
        }

        public DaifaTradeExample.Criteria andRealPayMoneyNotBetween(String value1, String value2) {
            return notBetween(realPayMoney, value1, value2);
        }
        public DaifaTradeExample.Criteria andReceiverStateIsNull() {
            return isNull(receiverState);
        }

        public DaifaTradeExample.Criteria andReceiverStateIsNotNull() {
            return isNotNull(receiverState);
        }

        public DaifaTradeExample.Criteria andReceiverStateEqualTo(String value) {
            return equalTo(receiverState, value);
        }

        public DaifaTradeExample.Criteria andReceiverStateNotEqualTo(String value) {
            return notEqualTo(receiverState, value);
        }

        public DaifaTradeExample.Criteria andReceiverStateGreaterThan(String value) {
            return greaterThan(receiverState, value);
        }

        public DaifaTradeExample.Criteria andReceiverStateGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(receiverState, value);
        }

        public DaifaTradeExample.Criteria andReceiverStateLessThan(String value) {
            return lessThan(receiverState, value);
        }

        public DaifaTradeExample.Criteria andReceiverStateLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(receiverState, value);
        }

        public DaifaTradeExample.Criteria andReceiverStateLike(String value) {
            return like(receiverState, value);
        }

        public DaifaTradeExample.Criteria andReceiverStateNotLike(String value) {
            return notLike(receiverState, value);
        }

        public DaifaTradeExample.Criteria andReceiverStateIn(List<String> values) {
            return in(receiverState, values);
        }

        public DaifaTradeExample.Criteria andReceiverStateNotIn(List<String> values) {
            return notIn(receiverState, values);
        }

        public DaifaTradeExample.Criteria andReceiverStateBetween(String value1, String value2) {
            return between(receiverState, value1, value2);
        }

        public DaifaTradeExample.Criteria andReceiverStateNotBetween(String value1, String value2) {
            return notBetween(receiverState, value1, value2);
        }
        public DaifaTradeExample.Criteria andPrintGgoodsStatusIsNull() {
            return isNull(printGgoodsStatus);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusIsNotNull() {
            return isNotNull(printGgoodsStatus);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusEqualTo(Integer value) {
            return equalTo(printGgoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusNotEqualTo(Integer value) {
            return notEqualTo(printGgoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusGreaterThan(Integer value) {
            return greaterThan(printGgoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(printGgoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusLessThan(Integer value) {
            return lessThan(printGgoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(printGgoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusIn(List<Integer> values) {
            return in(printGgoodsStatus, values);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusNotIn(List<Integer> values) {
            return notIn(printGgoodsStatus, values);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusBetween(Integer value1, Integer value2) {
            return between(printGgoodsStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andPrintGgoodsStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(printGgoodsStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andBuyerTelephoneIsNull() {
            return isNull(buyerTelephone);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneIsNotNull() {
            return isNotNull(buyerTelephone);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneEqualTo(String value) {
            return equalTo(buyerTelephone, value);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneNotEqualTo(String value) {
            return notEqualTo(buyerTelephone, value);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneGreaterThan(String value) {
            return greaterThan(buyerTelephone, value);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(buyerTelephone, value);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneLessThan(String value) {
            return lessThan(buyerTelephone, value);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(buyerTelephone, value);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneLike(String value) {
            return like(buyerTelephone, value);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneNotLike(String value) {
            return notLike(buyerTelephone, value);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneIn(List<String> values) {
            return in(buyerTelephone, values);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneNotIn(List<String> values) {
            return notIn(buyerTelephone, values);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneBetween(String value1, String value2) {
            return between(buyerTelephone, value1, value2);
        }

        public DaifaTradeExample.Criteria andBuyerTelephoneNotBetween(String value1, String value2) {
            return notBetween(buyerTelephone, value1, value2);
        }
        public DaifaTradeExample.Criteria andPostFeeBuIsNull() {
            return isNull(postFeeBu);
        }

        public DaifaTradeExample.Criteria andPostFeeBuIsNotNull() {
            return isNotNull(postFeeBu);
        }

        public DaifaTradeExample.Criteria andPostFeeBuEqualTo(String value) {
            return equalTo(postFeeBu, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuNotEqualTo(String value) {
            return notEqualTo(postFeeBu, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuGreaterThan(String value) {
            return greaterThan(postFeeBu, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(postFeeBu, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuLessThan(String value) {
            return lessThan(postFeeBu, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(postFeeBu, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuLike(String value) {
            return like(postFeeBu, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuNotLike(String value) {
            return notLike(postFeeBu, value);
        }

        public DaifaTradeExample.Criteria andPostFeeBuIn(List<String> values) {
            return in(postFeeBu, values);
        }

        public DaifaTradeExample.Criteria andPostFeeBuNotIn(List<String> values) {
            return notIn(postFeeBu, values);
        }

        public DaifaTradeExample.Criteria andPostFeeBuBetween(String value1, String value2) {
            return between(postFeeBu, value1, value2);
        }

        public DaifaTradeExample.Criteria andPostFeeBuNotBetween(String value1, String value2) {
            return notBetween(postFeeBu, value1, value2);
        }
        public DaifaTradeExample.Criteria andTradeFeeIsNull() {
            return isNull(tradeFee);
        }

        public DaifaTradeExample.Criteria andTradeFeeIsNotNull() {
            return isNotNull(tradeFee);
        }

        public DaifaTradeExample.Criteria andTradeFeeEqualTo(String value) {
            return equalTo(tradeFee, value);
        }

        public DaifaTradeExample.Criteria andTradeFeeNotEqualTo(String value) {
            return notEqualTo(tradeFee, value);
        }

        public DaifaTradeExample.Criteria andTradeFeeGreaterThan(String value) {
            return greaterThan(tradeFee, value);
        }

        public DaifaTradeExample.Criteria andTradeFeeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(tradeFee, value);
        }

        public DaifaTradeExample.Criteria andTradeFeeLessThan(String value) {
            return lessThan(tradeFee, value);
        }

        public DaifaTradeExample.Criteria andTradeFeeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(tradeFee, value);
        }

        public DaifaTradeExample.Criteria andTradeFeeLike(String value) {
            return like(tradeFee, value);
        }

        public DaifaTradeExample.Criteria andTradeFeeNotLike(String value) {
            return notLike(tradeFee, value);
        }

        public DaifaTradeExample.Criteria andTradeFeeIn(List<String> values) {
            return in(tradeFee, values);
        }

        public DaifaTradeExample.Criteria andTradeFeeNotIn(List<String> values) {
            return notIn(tradeFee, values);
        }

        public DaifaTradeExample.Criteria andTradeFeeBetween(String value1, String value2) {
            return between(tradeFee, value1, value2);
        }

        public DaifaTradeExample.Criteria andTradeFeeNotBetween(String value1, String value2) {
            return notBetween(tradeFee, value1, value2);
        }
        public DaifaTradeExample.Criteria andSellerNameIsNull() {
            return isNull(sellerName);
        }

        public DaifaTradeExample.Criteria andSellerNameIsNotNull() {
            return isNotNull(sellerName);
        }

        public DaifaTradeExample.Criteria andSellerNameEqualTo(String value) {
            return equalTo(sellerName, value);
        }

        public DaifaTradeExample.Criteria andSellerNameNotEqualTo(String value) {
            return notEqualTo(sellerName, value);
        }

        public DaifaTradeExample.Criteria andSellerNameGreaterThan(String value) {
            return greaterThan(sellerName, value);
        }

        public DaifaTradeExample.Criteria andSellerNameGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(sellerName, value);
        }

        public DaifaTradeExample.Criteria andSellerNameLessThan(String value) {
            return lessThan(sellerName, value);
        }

        public DaifaTradeExample.Criteria andSellerNameLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(sellerName, value);
        }

        public DaifaTradeExample.Criteria andSellerNameLike(String value) {
            return like(sellerName, value);
        }

        public DaifaTradeExample.Criteria andSellerNameNotLike(String value) {
            return notLike(sellerName, value);
        }

        public DaifaTradeExample.Criteria andSellerNameIn(List<String> values) {
            return in(sellerName, values);
        }

        public DaifaTradeExample.Criteria andSellerNameNotIn(List<String> values) {
            return notIn(sellerName, values);
        }

        public DaifaTradeExample.Criteria andSellerNameBetween(String value1, String value2) {
            return between(sellerName, value1, value2);
        }

        public DaifaTradeExample.Criteria andSellerNameNotBetween(String value1, String value2) {
            return notBetween(sellerName, value1, value2);
        }
        public DaifaTradeExample.Criteria andRefundStatusIsNull() {
            return isNull(refundStatus);
        }

        public DaifaTradeExample.Criteria andRefundStatusIsNotNull() {
            return isNotNull(refundStatus);
        }

        public DaifaTradeExample.Criteria andRefundStatusEqualTo(Integer value) {
            return equalTo(refundStatus, value);
        }

        public DaifaTradeExample.Criteria andRefundStatusNotEqualTo(Integer value) {
            return notEqualTo(refundStatus, value);
        }

        public DaifaTradeExample.Criteria andRefundStatusGreaterThan(Integer value) {
            return greaterThan(refundStatus, value);
        }

        public DaifaTradeExample.Criteria andRefundStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(refundStatus, value);
        }

        public DaifaTradeExample.Criteria andRefundStatusLessThan(Integer value) {
            return lessThan(refundStatus, value);
        }

        public DaifaTradeExample.Criteria andRefundStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(refundStatus, value);
        }

        public DaifaTradeExample.Criteria andRefundStatusIn(List<Integer> values) {
            return in(refundStatus, values);
        }

        public DaifaTradeExample.Criteria andRefundStatusNotIn(List<Integer> values) {
            return notIn(refundStatus, values);
        }

        public DaifaTradeExample.Criteria andRefundStatusBetween(Integer value1, Integer value2) {
            return between(refundStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andRefundStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(refundStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andPayPostIdIsNull() {
            return isNull(payPostId);
        }

        public DaifaTradeExample.Criteria andPayPostIdIsNotNull() {
            return isNotNull(payPostId);
        }

        public DaifaTradeExample.Criteria andPayPostIdEqualTo(String value) {
            return equalTo(payPostId, value);
        }

        public DaifaTradeExample.Criteria andPayPostIdNotEqualTo(String value) {
            return notEqualTo(payPostId, value);
        }

        public DaifaTradeExample.Criteria andPayPostIdGreaterThan(String value) {
            return greaterThan(payPostId, value);
        }

        public DaifaTradeExample.Criteria andPayPostIdGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(payPostId, value);
        }

        public DaifaTradeExample.Criteria andPayPostIdLessThan(String value) {
            return lessThan(payPostId, value);
        }

        public DaifaTradeExample.Criteria andPayPostIdLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(payPostId, value);
        }

        public DaifaTradeExample.Criteria andPayPostIdLike(String value) {
            return like(payPostId, value);
        }

        public DaifaTradeExample.Criteria andPayPostIdNotLike(String value) {
            return notLike(payPostId, value);
        }

        public DaifaTradeExample.Criteria andPayPostIdIn(List<String> values) {
            return in(payPostId, values);
        }

        public DaifaTradeExample.Criteria andPayPostIdNotIn(List<String> values) {
            return notIn(payPostId, values);
        }

        public DaifaTradeExample.Criteria andPayPostIdBetween(String value1, String value2) {
            return between(payPostId, value1, value2);
        }

        public DaifaTradeExample.Criteria andPayPostIdNotBetween(String value1, String value2) {
            return notBetween(payPostId, value1, value2);
        }
        public DaifaTradeExample.Criteria andIsTbSendIsNull() {
            return isNull(isTbSend);
        }

        public DaifaTradeExample.Criteria andIsTbSendIsNotNull() {
            return isNotNull(isTbSend);
        }

        public DaifaTradeExample.Criteria andIsTbSendEqualTo(Integer value) {
            return equalTo(isTbSend, value);
        }

        public DaifaTradeExample.Criteria andIsTbSendNotEqualTo(Integer value) {
            return notEqualTo(isTbSend, value);
        }

        public DaifaTradeExample.Criteria andIsTbSendGreaterThan(Integer value) {
            return greaterThan(isTbSend, value);
        }

        public DaifaTradeExample.Criteria andIsTbSendGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(isTbSend, value);
        }

        public DaifaTradeExample.Criteria andIsTbSendLessThan(Integer value) {
            return lessThan(isTbSend, value);
        }

        public DaifaTradeExample.Criteria andIsTbSendLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(isTbSend, value);
        }

        public DaifaTradeExample.Criteria andIsTbSendIn(List<Integer> values) {
            return in(isTbSend, values);
        }

        public DaifaTradeExample.Criteria andIsTbSendNotIn(List<Integer> values) {
            return notIn(isTbSend, values);
        }

        public DaifaTradeExample.Criteria andIsTbSendBetween(Integer value1, Integer value2) {
            return between(isTbSend, value1, value2);
        }

        public DaifaTradeExample.Criteria andIsTbSendNotBetween(Integer value1, Integer value2) {
            return notBetween(isTbSend, value1, value2);
        }
        public DaifaTradeExample.Criteria andExcelUrlIsNull() {
            return isNull(excelUrl);
        }

        public DaifaTradeExample.Criteria andExcelUrlIsNotNull() {
            return isNotNull(excelUrl);
        }

        public DaifaTradeExample.Criteria andExcelUrlEqualTo(String value) {
            return equalTo(excelUrl, value);
        }

        public DaifaTradeExample.Criteria andExcelUrlNotEqualTo(String value) {
            return notEqualTo(excelUrl, value);
        }

        public DaifaTradeExample.Criteria andExcelUrlGreaterThan(String value) {
            return greaterThan(excelUrl, value);
        }

        public DaifaTradeExample.Criteria andExcelUrlGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(excelUrl, value);
        }

        public DaifaTradeExample.Criteria andExcelUrlLessThan(String value) {
            return lessThan(excelUrl, value);
        }

        public DaifaTradeExample.Criteria andExcelUrlLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(excelUrl, value);
        }

        public DaifaTradeExample.Criteria andExcelUrlLike(String value) {
            return like(excelUrl, value);
        }

        public DaifaTradeExample.Criteria andExcelUrlNotLike(String value) {
            return notLike(excelUrl, value);
        }

        public DaifaTradeExample.Criteria andExcelUrlIn(List<String> values) {
            return in(excelUrl, values);
        }

        public DaifaTradeExample.Criteria andExcelUrlNotIn(List<String> values) {
            return notIn(excelUrl, values);
        }

        public DaifaTradeExample.Criteria andExcelUrlBetween(String value1, String value2) {
            return between(excelUrl, value1, value2);
        }

        public DaifaTradeExample.Criteria andExcelUrlNotBetween(String value1, String value2) {
            return notBetween(excelUrl, value1, value2);
        }
        public DaifaTradeExample.Criteria andReturnGoodsReasonIsNull() {
            return isNull(returnGoodsReason);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonIsNotNull() {
            return isNotNull(returnGoodsReason);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonEqualTo(String value) {
            return equalTo(returnGoodsReason, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonNotEqualTo(String value) {
            return notEqualTo(returnGoodsReason, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonGreaterThan(String value) {
            return greaterThan(returnGoodsReason, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(returnGoodsReason, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonLessThan(String value) {
            return lessThan(returnGoodsReason, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(returnGoodsReason, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonLike(String value) {
            return like(returnGoodsReason, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonNotLike(String value) {
            return notLike(returnGoodsReason, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonIn(List<String> values) {
            return in(returnGoodsReason, values);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonNotIn(List<String> values) {
            return notIn(returnGoodsReason, values);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonBetween(String value1, String value2) {
            return between(returnGoodsReason, value1, value2);
        }

        public DaifaTradeExample.Criteria andReturnGoodsReasonNotBetween(String value1, String value2) {
            return notBetween(returnGoodsReason, value1, value2);
        }
        public DaifaTradeExample.Criteria andBuyerWwIsNull() {
            return isNull(buyerWw);
        }

        public DaifaTradeExample.Criteria andBuyerWwIsNotNull() {
            return isNotNull(buyerWw);
        }

        public DaifaTradeExample.Criteria andBuyerWwEqualTo(String value) {
            return equalTo(buyerWw, value);
        }

        public DaifaTradeExample.Criteria andBuyerWwNotEqualTo(String value) {
            return notEqualTo(buyerWw, value);
        }

        public DaifaTradeExample.Criteria andBuyerWwGreaterThan(String value) {
            return greaterThan(buyerWw, value);
        }

        public DaifaTradeExample.Criteria andBuyerWwGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(buyerWw, value);
        }

        public DaifaTradeExample.Criteria andBuyerWwLessThan(String value) {
            return lessThan(buyerWw, value);
        }

        public DaifaTradeExample.Criteria andBuyerWwLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(buyerWw, value);
        }

        public DaifaTradeExample.Criteria andBuyerWwLike(String value) {
            return like(buyerWw, value);
        }

        public DaifaTradeExample.Criteria andBuyerWwNotLike(String value) {
            return notLike(buyerWw, value);
        }

        public DaifaTradeExample.Criteria andBuyerWwIn(List<String> values) {
            return in(buyerWw, values);
        }

        public DaifaTradeExample.Criteria andBuyerWwNotIn(List<String> values) {
            return notIn(buyerWw, values);
        }

        public DaifaTradeExample.Criteria andBuyerWwBetween(String value1, String value2) {
            return between(buyerWw, value1, value2);
        }

        public DaifaTradeExample.Criteria andBuyerWwNotBetween(String value1, String value2) {
            return notBetween(buyerWw, value1, value2);
        }
        public DaifaTradeExample.Criteria andZdPostFeeBuWorderIsNull() {
            return isNull(zdPostFeeBuWorder);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderIsNotNull() {
            return isNotNull(zdPostFeeBuWorder);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderEqualTo(String value) {
            return equalTo(zdPostFeeBuWorder, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderNotEqualTo(String value) {
            return notEqualTo(zdPostFeeBuWorder, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderGreaterThan(String value) {
            return greaterThan(zdPostFeeBuWorder, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(zdPostFeeBuWorder, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderLessThan(String value) {
            return lessThan(zdPostFeeBuWorder, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(zdPostFeeBuWorder, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderLike(String value) {
            return like(zdPostFeeBuWorder, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderNotLike(String value) {
            return notLike(zdPostFeeBuWorder, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderIn(List<String> values) {
            return in(zdPostFeeBuWorder, values);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderNotIn(List<String> values) {
            return notIn(zdPostFeeBuWorder, values);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderBetween(String value1, String value2) {
            return between(zdPostFeeBuWorder, value1, value2);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuWorderNotBetween(String value1, String value2) {
            return notBetween(zdPostFeeBuWorder, value1, value2);
        }
        public DaifaTradeExample.Criteria andBuyerWxIsNull() {
            return isNull(buyerWx);
        }

        public DaifaTradeExample.Criteria andBuyerWxIsNotNull() {
            return isNotNull(buyerWx);
        }

        public DaifaTradeExample.Criteria andBuyerWxEqualTo(String value) {
            return equalTo(buyerWx, value);
        }

        public DaifaTradeExample.Criteria andBuyerWxNotEqualTo(String value) {
            return notEqualTo(buyerWx, value);
        }

        public DaifaTradeExample.Criteria andBuyerWxGreaterThan(String value) {
            return greaterThan(buyerWx, value);
        }

        public DaifaTradeExample.Criteria andBuyerWxGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(buyerWx, value);
        }

        public DaifaTradeExample.Criteria andBuyerWxLessThan(String value) {
            return lessThan(buyerWx, value);
        }

        public DaifaTradeExample.Criteria andBuyerWxLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(buyerWx, value);
        }

        public DaifaTradeExample.Criteria andBuyerWxLike(String value) {
            return like(buyerWx, value);
        }

        public DaifaTradeExample.Criteria andBuyerWxNotLike(String value) {
            return notLike(buyerWx, value);
        }

        public DaifaTradeExample.Criteria andBuyerWxIn(List<String> values) {
            return in(buyerWx, values);
        }

        public DaifaTradeExample.Criteria andBuyerWxNotIn(List<String> values) {
            return notIn(buyerWx, values);
        }

        public DaifaTradeExample.Criteria andBuyerWxBetween(String value1, String value2) {
            return between(buyerWx, value1, value2);
        }

        public DaifaTradeExample.Criteria andBuyerWxNotBetween(String value1, String value2) {
            return notBetween(buyerWx, value1, value2);
        }
        public DaifaTradeExample.Criteria andPostNameIsNull() {
            return isNull(postName);
        }

        public DaifaTradeExample.Criteria andPostNameIsNotNull() {
            return isNotNull(postName);
        }

        public DaifaTradeExample.Criteria andPostNameEqualTo(String value) {
            return equalTo(postName, value);
        }

        public DaifaTradeExample.Criteria andPostNameNotEqualTo(String value) {
            return notEqualTo(postName, value);
        }

        public DaifaTradeExample.Criteria andPostNameGreaterThan(String value) {
            return greaterThan(postName, value);
        }

        public DaifaTradeExample.Criteria andPostNameGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(postName, value);
        }

        public DaifaTradeExample.Criteria andPostNameLessThan(String value) {
            return lessThan(postName, value);
        }

        public DaifaTradeExample.Criteria andPostNameLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(postName, value);
        }

        public DaifaTradeExample.Criteria andPostNameLike(String value) {
            return like(postName, value);
        }

        public DaifaTradeExample.Criteria andPostNameNotLike(String value) {
            return notLike(postName, value);
        }

        public DaifaTradeExample.Criteria andPostNameIn(List<String> values) {
            return in(postName, values);
        }

        public DaifaTradeExample.Criteria andPostNameNotIn(List<String> values) {
            return notIn(postName, values);
        }

        public DaifaTradeExample.Criteria andPostNameBetween(String value1, String value2) {
            return between(postName, value1, value2);
        }

        public DaifaTradeExample.Criteria andPostNameNotBetween(String value1, String value2) {
            return notBetween(postName, value1, value2);
        }
        public DaifaTradeExample.Criteria andAgreeSplitIsNull() {
            return isNull(agreeSplit);
        }

        public DaifaTradeExample.Criteria andAgreeSplitIsNotNull() {
            return isNotNull(agreeSplit);
        }

        public DaifaTradeExample.Criteria andAgreeSplitEqualTo(Integer value) {
            return equalTo(agreeSplit, value);
        }

        public DaifaTradeExample.Criteria andAgreeSplitNotEqualTo(Integer value) {
            return notEqualTo(agreeSplit, value);
        }

        public DaifaTradeExample.Criteria andAgreeSplitGreaterThan(Integer value) {
            return greaterThan(agreeSplit, value);
        }

        public DaifaTradeExample.Criteria andAgreeSplitGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(agreeSplit, value);
        }

        public DaifaTradeExample.Criteria andAgreeSplitLessThan(Integer value) {
            return lessThan(agreeSplit, value);
        }

        public DaifaTradeExample.Criteria andAgreeSplitLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(agreeSplit, value);
        }

        public DaifaTradeExample.Criteria andAgreeSplitIn(List<Integer> values) {
            return in(agreeSplit, values);
        }

        public DaifaTradeExample.Criteria andAgreeSplitNotIn(List<Integer> values) {
            return notIn(agreeSplit, values);
        }

        public DaifaTradeExample.Criteria andAgreeSplitBetween(Integer value1, Integer value2) {
            return between(agreeSplit, value1, value2);
        }

        public DaifaTradeExample.Criteria andAgreeSplitNotBetween(Integer value1, Integer value2) {
            return notBetween(agreeSplit, value1, value2);
        }
        public DaifaTradeExample.Criteria andBigCustFlagIsNull() {
            return isNull(bigCustFlag);
        }

        public DaifaTradeExample.Criteria andBigCustFlagIsNotNull() {
            return isNotNull(bigCustFlag);
        }

        public DaifaTradeExample.Criteria andBigCustFlagEqualTo(Integer value) {
            return equalTo(bigCustFlag, value);
        }

        public DaifaTradeExample.Criteria andBigCustFlagNotEqualTo(Integer value) {
            return notEqualTo(bigCustFlag, value);
        }

        public DaifaTradeExample.Criteria andBigCustFlagGreaterThan(Integer value) {
            return greaterThan(bigCustFlag, value);
        }

        public DaifaTradeExample.Criteria andBigCustFlagGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(bigCustFlag, value);
        }

        public DaifaTradeExample.Criteria andBigCustFlagLessThan(Integer value) {
            return lessThan(bigCustFlag, value);
        }

        public DaifaTradeExample.Criteria andBigCustFlagLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(bigCustFlag, value);
        }

        public DaifaTradeExample.Criteria andBigCustFlagIn(List<Integer> values) {
            return in(bigCustFlag, values);
        }

        public DaifaTradeExample.Criteria andBigCustFlagNotIn(List<Integer> values) {
            return notIn(bigCustFlag, values);
        }

        public DaifaTradeExample.Criteria andBigCustFlagBetween(Integer value1, Integer value2) {
            return between(bigCustFlag, value1, value2);
        }

        public DaifaTradeExample.Criteria andBigCustFlagNotBetween(Integer value1, Integer value2) {
            return notBetween(bigCustFlag, value1, value2);
        }
        public DaifaTradeExample.Criteria andCdkeyStatusIsNull() {
            return isNull(cdkeyStatus);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusIsNotNull() {
            return isNotNull(cdkeyStatus);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusEqualTo(Integer value) {
            return equalTo(cdkeyStatus, value);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusNotEqualTo(Integer value) {
            return notEqualTo(cdkeyStatus, value);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusGreaterThan(Integer value) {
            return greaterThan(cdkeyStatus, value);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(cdkeyStatus, value);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusLessThan(Integer value) {
            return lessThan(cdkeyStatus, value);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(cdkeyStatus, value);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusIn(List<Integer> values) {
            return in(cdkeyStatus, values);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusNotIn(List<Integer> values) {
            return notIn(cdkeyStatus, values);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusBetween(Integer value1, Integer value2) {
            return between(cdkeyStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andCdkeyStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(cdkeyStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andPostFeeIsNull() {
            return isNull(postFee);
        }

        public DaifaTradeExample.Criteria andPostFeeIsNotNull() {
            return isNotNull(postFee);
        }

        public DaifaTradeExample.Criteria andPostFeeEqualTo(String value) {
            return equalTo(postFee, value);
        }

        public DaifaTradeExample.Criteria andPostFeeNotEqualTo(String value) {
            return notEqualTo(postFee, value);
        }

        public DaifaTradeExample.Criteria andPostFeeGreaterThan(String value) {
            return greaterThan(postFee, value);
        }

        public DaifaTradeExample.Criteria andPostFeeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(postFee, value);
        }

        public DaifaTradeExample.Criteria andPostFeeLessThan(String value) {
            return lessThan(postFee, value);
        }

        public DaifaTradeExample.Criteria andPostFeeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(postFee, value);
        }

        public DaifaTradeExample.Criteria andPostFeeLike(String value) {
            return like(postFee, value);
        }

        public DaifaTradeExample.Criteria andPostFeeNotLike(String value) {
            return notLike(postFee, value);
        }

        public DaifaTradeExample.Criteria andPostFeeIn(List<String> values) {
            return in(postFee, values);
        }

        public DaifaTradeExample.Criteria andPostFeeNotIn(List<String> values) {
            return notIn(postFee, values);
        }

        public DaifaTradeExample.Criteria andPostFeeBetween(String value1, String value2) {
            return between(postFee, value1, value2);
        }

        public DaifaTradeExample.Criteria andPostFeeNotBetween(String value1, String value2) {
            return notBetween(postFee, value1, value2);
        }
        public DaifaTradeExample.Criteria andReceiverMobileIsNull() {
            return isNull(receiverMobile);
        }

        public DaifaTradeExample.Criteria andReceiverMobileIsNotNull() {
            return isNotNull(receiverMobile);
        }

        public DaifaTradeExample.Criteria andReceiverMobileEqualTo(String value) {
            return equalTo(receiverMobile, value);
        }

        public DaifaTradeExample.Criteria andReceiverMobileNotEqualTo(String value) {
            return notEqualTo(receiverMobile, value);
        }

        public DaifaTradeExample.Criteria andReceiverMobileGreaterThan(String value) {
            return greaterThan(receiverMobile, value);
        }

        public DaifaTradeExample.Criteria andReceiverMobileGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(receiverMobile, value);
        }

        public DaifaTradeExample.Criteria andReceiverMobileLessThan(String value) {
            return lessThan(receiverMobile, value);
        }

        public DaifaTradeExample.Criteria andReceiverMobileLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(receiverMobile, value);
        }

        public DaifaTradeExample.Criteria andReceiverMobileLike(String value) {
            return like(receiverMobile, value);
        }

        public DaifaTradeExample.Criteria andReceiverMobileNotLike(String value) {
            return notLike(receiverMobile, value);
        }

        public DaifaTradeExample.Criteria andReceiverMobileIn(List<String> values) {
            return in(receiverMobile, values);
        }

        public DaifaTradeExample.Criteria andReceiverMobileNotIn(List<String> values) {
            return notIn(receiverMobile, values);
        }

        public DaifaTradeExample.Criteria andReceiverMobileBetween(String value1, String value2) {
            return between(receiverMobile, value1, value2);
        }

        public DaifaTradeExample.Criteria andReceiverMobileNotBetween(String value1, String value2) {
            return notBetween(receiverMobile, value1, value2);
        }
        public DaifaTradeExample.Criteria andBuyerNameIsNull() {
            return isNull(buyerName);
        }

        public DaifaTradeExample.Criteria andBuyerNameIsNotNull() {
            return isNotNull(buyerName);
        }

        public DaifaTradeExample.Criteria andBuyerNameEqualTo(String value) {
            return equalTo(buyerName, value);
        }

        public DaifaTradeExample.Criteria andBuyerNameNotEqualTo(String value) {
            return notEqualTo(buyerName, value);
        }

        public DaifaTradeExample.Criteria andBuyerNameGreaterThan(String value) {
            return greaterThan(buyerName, value);
        }

        public DaifaTradeExample.Criteria andBuyerNameGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(buyerName, value);
        }

        public DaifaTradeExample.Criteria andBuyerNameLessThan(String value) {
            return lessThan(buyerName, value);
        }

        public DaifaTradeExample.Criteria andBuyerNameLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(buyerName, value);
        }

        public DaifaTradeExample.Criteria andBuyerNameLike(String value) {
            return like(buyerName, value);
        }

        public DaifaTradeExample.Criteria andBuyerNameNotLike(String value) {
            return notLike(buyerName, value);
        }

        public DaifaTradeExample.Criteria andBuyerNameIn(List<String> values) {
            return in(buyerName, values);
        }

        public DaifaTradeExample.Criteria andBuyerNameNotIn(List<String> values) {
            return notIn(buyerName, values);
        }

        public DaifaTradeExample.Criteria andBuyerNameBetween(String value1, String value2) {
            return between(buyerName, value1, value2);
        }

        public DaifaTradeExample.Criteria andBuyerNameNotBetween(String value1, String value2) {
            return notBetween(buyerName, value1, value2);
        }
        public DaifaTradeExample.Criteria andTaobaoTidIsNull() {
            return isNull(taobaoTid);
        }

        public DaifaTradeExample.Criteria andTaobaoTidIsNotNull() {
            return isNotNull(taobaoTid);
        }

        public DaifaTradeExample.Criteria andTaobaoTidEqualTo(Long value) {
            return equalTo(taobaoTid, value);
        }

        public DaifaTradeExample.Criteria andTaobaoTidNotEqualTo(Long value) {
            return notEqualTo(taobaoTid, value);
        }

        public DaifaTradeExample.Criteria andTaobaoTidGreaterThan(Long value) {
            return greaterThan(taobaoTid, value);
        }

        public DaifaTradeExample.Criteria andTaobaoTidGreaterThanOrEqualTo(Long value) {
            return greaterThanOrEqualTo(taobaoTid, value);
        }

        public DaifaTradeExample.Criteria andTaobaoTidLessThan(Long value) {
            return lessThan(taobaoTid, value);
        }

        public DaifaTradeExample.Criteria andTaobaoTidLessThanOrEqualTo(Long value) {
            return lessThanOrEqualTo(taobaoTid, value);
        }

        public DaifaTradeExample.Criteria andTaobaoTidIn(List<Long> values) {
            return in(taobaoTid, values);
        }

        public DaifaTradeExample.Criteria andTaobaoTidNotIn(List<Long> values) {
            return notIn(taobaoTid, values);
        }

        public DaifaTradeExample.Criteria andTaobaoTidBetween(Long value1, Long value2) {
            return between(taobaoTid, value1, value2);
        }

        public DaifaTradeExample.Criteria andTaobaoTidNotBetween(Long value1, Long value2) {
            return notBetween(taobaoTid, value1, value2);
        }
        public DaifaTradeExample.Criteria andDFTradeREMARK1IsNull() {
            return isNull(DFTradeREMARK1);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1IsNotNull() {
            return isNotNull(DFTradeREMARK1);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1EqualTo(String value) {
            return equalTo(DFTradeREMARK1, value);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1NotEqualTo(String value) {
            return notEqualTo(DFTradeREMARK1, value);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1GreaterThan(String value) {
            return greaterThan(DFTradeREMARK1, value);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(DFTradeREMARK1, value);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1LessThan(String value) {
            return lessThan(DFTradeREMARK1, value);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(DFTradeREMARK1, value);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1Like(String value) {
            return like(DFTradeREMARK1, value);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1NotLike(String value) {
            return notLike(DFTradeREMARK1, value);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1In(List<String> values) {
            return in(DFTradeREMARK1, values);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1NotIn(List<String> values) {
            return notIn(DFTradeREMARK1, values);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1Between(String value1, String value2) {
            return between(DFTradeREMARK1, value1, value2);
        }

        public DaifaTradeExample.Criteria andDFTradeREMARK1NotBetween(String value1, String value2) {
            return notBetween(DFTradeREMARK1, value1, value2);
        }
        public DaifaTradeExample.Criteria andTuiFeeReasonIsNull() {
            return isNull(tuiFeeReason);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonIsNotNull() {
            return isNotNull(tuiFeeReason);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonEqualTo(String value) {
            return equalTo(tuiFeeReason, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonNotEqualTo(String value) {
            return notEqualTo(tuiFeeReason, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonGreaterThan(String value) {
            return greaterThan(tuiFeeReason, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(tuiFeeReason, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonLessThan(String value) {
            return lessThan(tuiFeeReason, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(tuiFeeReason, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonLike(String value) {
            return like(tuiFeeReason, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonNotLike(String value) {
            return notLike(tuiFeeReason, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonIn(List<String> values) {
            return in(tuiFeeReason, values);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonNotIn(List<String> values) {
            return notIn(tuiFeeReason, values);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonBetween(String value1, String value2) {
            return between(tuiFeeReason, value1, value2);
        }

        public DaifaTradeExample.Criteria andTuiFeeReasonNotBetween(String value1, String value2) {
            return notBetween(tuiFeeReason, value1, value2);
        }
        public DaifaTradeExample.Criteria andCreateTimeIsNull() {
            return isNull(createTime);
        }

        public DaifaTradeExample.Criteria andCreateTimeIsNotNull() {
            return isNotNull(createTime);
        }

        public DaifaTradeExample.Criteria andCreateTimeEqualTo(Date value) {
            return equalTo(createTime, value);
        }

        public DaifaTradeExample.Criteria andCreateTimeNotEqualTo(Date value) {
            return notEqualTo(createTime, value);
        }

        public DaifaTradeExample.Criteria andCreateTimeGreaterThan(Date value) {
            return greaterThan(createTime, value);
        }

        public DaifaTradeExample.Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(createTime, value);
        }

        public DaifaTradeExample.Criteria andCreateTimeLessThan(Date value) {
            return lessThan(createTime, value);
        }

        public DaifaTradeExample.Criteria andCreateTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(createTime, value);
        }

        public DaifaTradeExample.Criteria andCreateTimeIn(List<Date> values) {
            return in(createTime, values);
        }

        public DaifaTradeExample.Criteria andCreateTimeNotIn(List<Date> values) {
            return notIn(createTime, values);
        }

        public DaifaTradeExample.Criteria andCreateTimeBetween(Date value1, Date value2) {
            return between(createTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andCreateTimeNotBetween(Date value1, Date value2) {
            return notBetween(createTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andReturnPostCodeIsNull() {
            return isNull(returnPostCode);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeIsNotNull() {
            return isNotNull(returnPostCode);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeEqualTo(String value) {
            return equalTo(returnPostCode, value);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeNotEqualTo(String value) {
            return notEqualTo(returnPostCode, value);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeGreaterThan(String value) {
            return greaterThan(returnPostCode, value);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(returnPostCode, value);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeLessThan(String value) {
            return lessThan(returnPostCode, value);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(returnPostCode, value);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeLike(String value) {
            return like(returnPostCode, value);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeNotLike(String value) {
            return notLike(returnPostCode, value);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeIn(List<String> values) {
            return in(returnPostCode, values);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeNotIn(List<String> values) {
            return notIn(returnPostCode, values);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeBetween(String value1, String value2) {
            return between(returnPostCode, value1, value2);
        }

        public DaifaTradeExample.Criteria andReturnPostCodeNotBetween(String value1, String value2) {
            return notBetween(returnPostCode, value1, value2);
        }
        public DaifaTradeExample.Criteria andSendStatusIsNull() {
            return isNull(sendStatus);
        }

        public DaifaTradeExample.Criteria andSendStatusIsNotNull() {
            return isNotNull(sendStatus);
        }

        public DaifaTradeExample.Criteria andSendStatusEqualTo(Integer value) {
            return equalTo(sendStatus, value);
        }

        public DaifaTradeExample.Criteria andSendStatusNotEqualTo(Integer value) {
            return notEqualTo(sendStatus, value);
        }

        public DaifaTradeExample.Criteria andSendStatusGreaterThan(Integer value) {
            return greaterThan(sendStatus, value);
        }

        public DaifaTradeExample.Criteria andSendStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(sendStatus, value);
        }

        public DaifaTradeExample.Criteria andSendStatusLessThan(Integer value) {
            return lessThan(sendStatus, value);
        }

        public DaifaTradeExample.Criteria andSendStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(sendStatus, value);
        }

        public DaifaTradeExample.Criteria andSendStatusIn(List<Integer> values) {
            return in(sendStatus, values);
        }

        public DaifaTradeExample.Criteria andSendStatusNotIn(List<Integer> values) {
            return notIn(sendStatus, values);
        }

        public DaifaTradeExample.Criteria andSendStatusBetween(Integer value1, Integer value2) {
            return between(sendStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andSendStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(sendStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andPayTimeIsNull() {
            return isNull(payTime);
        }

        public DaifaTradeExample.Criteria andPayTimeIsNotNull() {
            return isNotNull(payTime);
        }

        public DaifaTradeExample.Criteria andPayTimeEqualTo(Date value) {
            return equalTo(payTime, value);
        }

        public DaifaTradeExample.Criteria andPayTimeNotEqualTo(Date value) {
            return notEqualTo(payTime, value);
        }

        public DaifaTradeExample.Criteria andPayTimeGreaterThan(Date value) {
            return greaterThan(payTime, value);
        }

        public DaifaTradeExample.Criteria andPayTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(payTime, value);
        }

        public DaifaTradeExample.Criteria andPayTimeLessThan(Date value) {
            return lessThan(payTime, value);
        }

        public DaifaTradeExample.Criteria andPayTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(payTime, value);
        }

        public DaifaTradeExample.Criteria andPayTimeIn(List<Date> values) {
            return in(payTime, values);
        }

        public DaifaTradeExample.Criteria andPayTimeNotIn(List<Date> values) {
            return notIn(payTime, values);
        }

        public DaifaTradeExample.Criteria andPayTimeBetween(Date value1, Date value2) {
            return between(payTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andPayTimeNotBetween(Date value1, Date value2) {
            return notBetween(payTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andPayWayIsNull() {
            return isNull(payWay);
        }

        public DaifaTradeExample.Criteria andPayWayIsNotNull() {
            return isNotNull(payWay);
        }

        public DaifaTradeExample.Criteria andPayWayEqualTo(String value) {
            return equalTo(payWay, value);
        }

        public DaifaTradeExample.Criteria andPayWayNotEqualTo(String value) {
            return notEqualTo(payWay, value);
        }

        public DaifaTradeExample.Criteria andPayWayGreaterThan(String value) {
            return greaterThan(payWay, value);
        }

        public DaifaTradeExample.Criteria andPayWayGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(payWay, value);
        }

        public DaifaTradeExample.Criteria andPayWayLessThan(String value) {
            return lessThan(payWay, value);
        }

        public DaifaTradeExample.Criteria andPayWayLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(payWay, value);
        }

        public DaifaTradeExample.Criteria andPayWayLike(String value) {
            return like(payWay, value);
        }

        public DaifaTradeExample.Criteria andPayWayNotLike(String value) {
            return notLike(payWay, value);
        }

        public DaifaTradeExample.Criteria andPayWayIn(List<String> values) {
            return in(payWay, values);
        }

        public DaifaTradeExample.Criteria andPayWayNotIn(List<String> values) {
            return notIn(payWay, values);
        }

        public DaifaTradeExample.Criteria andPayWayBetween(String value1, String value2) {
            return between(payWay, value1, value2);
        }

        public DaifaTradeExample.Criteria andPayWayNotBetween(String value1, String value2) {
            return notBetween(payWay, value1, value2);
        }
        public DaifaTradeExample.Criteria andBuyerIdIsNull() {
            return isNull(buyerId);
        }

        public DaifaTradeExample.Criteria andBuyerIdIsNotNull() {
            return isNotNull(buyerId);
        }

        public DaifaTradeExample.Criteria andBuyerIdEqualTo(Long value) {
            return equalTo(buyerId, value);
        }

        public DaifaTradeExample.Criteria andBuyerIdNotEqualTo(Long value) {
            return notEqualTo(buyerId, value);
        }

        public DaifaTradeExample.Criteria andBuyerIdGreaterThan(Long value) {
            return greaterThan(buyerId, value);
        }

        public DaifaTradeExample.Criteria andBuyerIdGreaterThanOrEqualTo(Long value) {
            return greaterThanOrEqualTo(buyerId, value);
        }

        public DaifaTradeExample.Criteria andBuyerIdLessThan(Long value) {
            return lessThan(buyerId, value);
        }

        public DaifaTradeExample.Criteria andBuyerIdLessThanOrEqualTo(Long value) {
            return lessThanOrEqualTo(buyerId, value);
        }

        public DaifaTradeExample.Criteria andBuyerIdIn(List<Long> values) {
            return in(buyerId, values);
        }

        public DaifaTradeExample.Criteria andBuyerIdNotIn(List<Long> values) {
            return notIn(buyerId, values);
        }

        public DaifaTradeExample.Criteria andBuyerIdBetween(Long value1, Long value2) {
            return between(buyerId, value1, value2);
        }

        public DaifaTradeExample.Criteria andBuyerIdNotBetween(Long value1, Long value2) {
            return notBetween(buyerId, value1, value2);
        }
        public DaifaTradeExample.Criteria andAtchingStatusIsNull() {
            return isNull(atchingStatus);
        }

        public DaifaTradeExample.Criteria andAtchingStatusIsNotNull() {
            return isNotNull(atchingStatus);
        }

        public DaifaTradeExample.Criteria andAtchingStatusEqualTo(Integer value) {
            return equalTo(atchingStatus, value);
        }

        public DaifaTradeExample.Criteria andAtchingStatusNotEqualTo(Integer value) {
            return notEqualTo(atchingStatus, value);
        }

        public DaifaTradeExample.Criteria andAtchingStatusGreaterThan(Integer value) {
            return greaterThan(atchingStatus, value);
        }

        public DaifaTradeExample.Criteria andAtchingStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(atchingStatus, value);
        }

        public DaifaTradeExample.Criteria andAtchingStatusLessThan(Integer value) {
            return lessThan(atchingStatus, value);
        }

        public DaifaTradeExample.Criteria andAtchingStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(atchingStatus, value);
        }

        public DaifaTradeExample.Criteria andAtchingStatusIn(List<Integer> values) {
            return in(atchingStatus, values);
        }

        public DaifaTradeExample.Criteria andAtchingStatusNotIn(List<Integer> values) {
            return notIn(atchingStatus, values);
        }

        public DaifaTradeExample.Criteria andAtchingStatusBetween(Integer value1, Integer value2) {
            return between(atchingStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andAtchingStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(atchingStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andBuyerQqIsNull() {
            return isNull(buyerQq);
        }

        public DaifaTradeExample.Criteria andBuyerQqIsNotNull() {
            return isNotNull(buyerQq);
        }

        public DaifaTradeExample.Criteria andBuyerQqEqualTo(String value) {
            return equalTo(buyerQq, value);
        }

        public DaifaTradeExample.Criteria andBuyerQqNotEqualTo(String value) {
            return notEqualTo(buyerQq, value);
        }

        public DaifaTradeExample.Criteria andBuyerQqGreaterThan(String value) {
            return greaterThan(buyerQq, value);
        }

        public DaifaTradeExample.Criteria andBuyerQqGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(buyerQq, value);
        }

        public DaifaTradeExample.Criteria andBuyerQqLessThan(String value) {
            return lessThan(buyerQq, value);
        }

        public DaifaTradeExample.Criteria andBuyerQqLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(buyerQq, value);
        }

        public DaifaTradeExample.Criteria andBuyerQqLike(String value) {
            return like(buyerQq, value);
        }

        public DaifaTradeExample.Criteria andBuyerQqNotLike(String value) {
            return notLike(buyerQq, value);
        }

        public DaifaTradeExample.Criteria andBuyerQqIn(List<String> values) {
            return in(buyerQq, values);
        }

        public DaifaTradeExample.Criteria andBuyerQqNotIn(List<String> values) {
            return notIn(buyerQq, values);
        }

        public DaifaTradeExample.Criteria andBuyerQqBetween(String value1, String value2) {
            return between(buyerQq, value1, value2);
        }

        public DaifaTradeExample.Criteria andBuyerQqNotBetween(String value1, String value2) {
            return notBetween(buyerQq, value1, value2);
        }
        public DaifaTradeExample.Criteria andBuyerRemarkIsNull() {
            return isNull(buyerRemark);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkIsNotNull() {
            return isNotNull(buyerRemark);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkEqualTo(String value) {
            return equalTo(buyerRemark, value);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkNotEqualTo(String value) {
            return notEqualTo(buyerRemark, value);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkGreaterThan(String value) {
            return greaterThan(buyerRemark, value);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(buyerRemark, value);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkLessThan(String value) {
            return lessThan(buyerRemark, value);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(buyerRemark, value);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkLike(String value) {
            return like(buyerRemark, value);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkNotLike(String value) {
            return notLike(buyerRemark, value);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkIn(List<String> values) {
            return in(buyerRemark, values);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkNotIn(List<String> values) {
            return notIn(buyerRemark, values);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkBetween(String value1, String value2) {
            return between(buyerRemark, value1, value2);
        }

        public DaifaTradeExample.Criteria andBuyerRemarkNotBetween(String value1, String value2) {
            return notBetween(buyerRemark, value1, value2);
        }
        public DaifaTradeExample.Criteria andSellerIdIsNull() {
            return isNull(sellerId);
        }

        public DaifaTradeExample.Criteria andSellerIdIsNotNull() {
            return isNotNull(sellerId);
        }

        public DaifaTradeExample.Criteria andSellerIdEqualTo(Long value) {
            return equalTo(sellerId, value);
        }

        public DaifaTradeExample.Criteria andSellerIdNotEqualTo(Long value) {
            return notEqualTo(sellerId, value);
        }

        public DaifaTradeExample.Criteria andSellerIdGreaterThan(Long value) {
            return greaterThan(sellerId, value);
        }

        public DaifaTradeExample.Criteria andSellerIdGreaterThanOrEqualTo(Long value) {
            return greaterThanOrEqualTo(sellerId, value);
        }

        public DaifaTradeExample.Criteria andSellerIdLessThan(Long value) {
            return lessThan(sellerId, value);
        }

        public DaifaTradeExample.Criteria andSellerIdLessThanOrEqualTo(Long value) {
            return lessThanOrEqualTo(sellerId, value);
        }

        public DaifaTradeExample.Criteria andSellerIdIn(List<Long> values) {
            return in(sellerId, values);
        }

        public DaifaTradeExample.Criteria andSellerIdNotIn(List<Long> values) {
            return notIn(sellerId, values);
        }

        public DaifaTradeExample.Criteria andSellerIdBetween(Long value1, Long value2) {
            return between(sellerId, value1, value2);
        }

        public DaifaTradeExample.Criteria andSellerIdNotBetween(Long value1, Long value2) {
            return notBetween(sellerId, value1, value2);
        }
        public DaifaTradeExample.Criteria andModifyTimeIsNull() {
            return isNull(modifyTime);
        }

        public DaifaTradeExample.Criteria andModifyTimeIsNotNull() {
            return isNotNull(modifyTime);
        }

        public DaifaTradeExample.Criteria andModifyTimeEqualTo(Date value) {
            return equalTo(modifyTime, value);
        }

        public DaifaTradeExample.Criteria andModifyTimeNotEqualTo(Date value) {
            return notEqualTo(modifyTime, value);
        }

        public DaifaTradeExample.Criteria andModifyTimeGreaterThan(Date value) {
            return greaterThan(modifyTime, value);
        }

        public DaifaTradeExample.Criteria andModifyTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(modifyTime, value);
        }

        public DaifaTradeExample.Criteria andModifyTimeLessThan(Date value) {
            return lessThan(modifyTime, value);
        }

        public DaifaTradeExample.Criteria andModifyTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(modifyTime, value);
        }

        public DaifaTradeExample.Criteria andModifyTimeIn(List<Date> values) {
            return in(modifyTime, values);
        }

        public DaifaTradeExample.Criteria andModifyTimeNotIn(List<Date> values) {
            return notIn(modifyTime, values);
        }

        public DaifaTradeExample.Criteria andModifyTimeBetween(Date value1, Date value2) {
            return between(modifyTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andModifyTimeNotBetween(Date value1, Date value2) {
            return notBetween(modifyTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andReqRefundTimeIsNull() {
            return isNull(reqRefundTime);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeIsNotNull() {
            return isNotNull(reqRefundTime);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeEqualTo(Date value) {
            return equalTo(reqRefundTime, value);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeNotEqualTo(Date value) {
            return notEqualTo(reqRefundTime, value);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeGreaterThan(Date value) {
            return greaterThan(reqRefundTime, value);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(reqRefundTime, value);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeLessThan(Date value) {
            return lessThan(reqRefundTime, value);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(reqRefundTime, value);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeIn(List<Date> values) {
            return in(reqRefundTime, values);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeNotIn(List<Date> values) {
            return notIn(reqRefundTime, values);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeBetween(Date value1, Date value2) {
            return between(reqRefundTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andReqRefundTimeNotBetween(Date value1, Date value2) {
            return notBetween(reqRefundTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andDaifaFeeIsNull() {
            return isNull(daifaFee);
        }

        public DaifaTradeExample.Criteria andDaifaFeeIsNotNull() {
            return isNotNull(daifaFee);
        }

        public DaifaTradeExample.Criteria andDaifaFeeEqualTo(String value) {
            return equalTo(daifaFee, value);
        }

        public DaifaTradeExample.Criteria andDaifaFeeNotEqualTo(String value) {
            return notEqualTo(daifaFee, value);
        }

        public DaifaTradeExample.Criteria andDaifaFeeGreaterThan(String value) {
            return greaterThan(daifaFee, value);
        }

        public DaifaTradeExample.Criteria andDaifaFeeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(daifaFee, value);
        }

        public DaifaTradeExample.Criteria andDaifaFeeLessThan(String value) {
            return lessThan(daifaFee, value);
        }

        public DaifaTradeExample.Criteria andDaifaFeeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(daifaFee, value);
        }

        public DaifaTradeExample.Criteria andDaifaFeeLike(String value) {
            return like(daifaFee, value);
        }

        public DaifaTradeExample.Criteria andDaifaFeeNotLike(String value) {
            return notLike(daifaFee, value);
        }

        public DaifaTradeExample.Criteria andDaifaFeeIn(List<String> values) {
            return in(daifaFee, values);
        }

        public DaifaTradeExample.Criteria andDaifaFeeNotIn(List<String> values) {
            return notIn(daifaFee, values);
        }

        public DaifaTradeExample.Criteria andDaifaFeeBetween(String value1, String value2) {
            return between(daifaFee, value1, value2);
        }

        public DaifaTradeExample.Criteria andDaifaFeeNotBetween(String value1, String value2) {
            return notBetween(daifaFee, value1, value2);
        }
        public DaifaTradeExample.Criteria andOrderReceivingTimeIsNull() {
            return isNull(orderReceivingTime);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeIsNotNull() {
            return isNotNull(orderReceivingTime);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeEqualTo(Date value) {
            return equalTo(orderReceivingTime, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeNotEqualTo(Date value) {
            return notEqualTo(orderReceivingTime, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeGreaterThan(Date value) {
            return greaterThan(orderReceivingTime, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(orderReceivingTime, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeLessThan(Date value) {
            return lessThan(orderReceivingTime, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(orderReceivingTime, value);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeIn(List<Date> values) {
            return in(orderReceivingTime, values);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeNotIn(List<Date> values) {
            return notIn(orderReceivingTime, values);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeBetween(Date value1, Date value2) {
            return between(orderReceivingTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andOrderReceivingTimeNotBetween(Date value1, Date value2) {
            return notBetween(orderReceivingTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andNotPayPostIsNull() {
            return isNull(notPayPost);
        }

        public DaifaTradeExample.Criteria andNotPayPostIsNotNull() {
            return isNotNull(notPayPost);
        }

        public DaifaTradeExample.Criteria andNotPayPostEqualTo(Integer value) {
            return equalTo(notPayPost, value);
        }

        public DaifaTradeExample.Criteria andNotPayPostNotEqualTo(Integer value) {
            return notEqualTo(notPayPost, value);
        }

        public DaifaTradeExample.Criteria andNotPayPostGreaterThan(Integer value) {
            return greaterThan(notPayPost, value);
        }

        public DaifaTradeExample.Criteria andNotPayPostGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(notPayPost, value);
        }

        public DaifaTradeExample.Criteria andNotPayPostLessThan(Integer value) {
            return lessThan(notPayPost, value);
        }

        public DaifaTradeExample.Criteria andNotPayPostLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(notPayPost, value);
        }

        public DaifaTradeExample.Criteria andNotPayPostIn(List<Integer> values) {
            return in(notPayPost, values);
        }

        public DaifaTradeExample.Criteria andNotPayPostNotIn(List<Integer> values) {
            return notIn(notPayPost, values);
        }

        public DaifaTradeExample.Criteria andNotPayPostBetween(Integer value1, Integer value2) {
            return between(notPayPost, value1, value2);
        }

        public DaifaTradeExample.Criteria andNotPayPostNotBetween(Integer value1, Integer value2) {
            return notBetween(notPayPost, value1, value2);
        }
        public DaifaTradeExample.Criteria andLastDoTimeIsNull() {
            return isNull(lastDoTime);
        }

        public DaifaTradeExample.Criteria andLastDoTimeIsNotNull() {
            return isNotNull(lastDoTime);
        }

        public DaifaTradeExample.Criteria andLastDoTimeEqualTo(Date value) {
            return equalTo(lastDoTime, value);
        }

        public DaifaTradeExample.Criteria andLastDoTimeNotEqualTo(Date value) {
            return notEqualTo(lastDoTime, value);
        }

        public DaifaTradeExample.Criteria andLastDoTimeGreaterThan(Date value) {
            return greaterThan(lastDoTime, value);
        }

        public DaifaTradeExample.Criteria andLastDoTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(lastDoTime, value);
        }

        public DaifaTradeExample.Criteria andLastDoTimeLessThan(Date value) {
            return lessThan(lastDoTime, value);
        }

        public DaifaTradeExample.Criteria andLastDoTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(lastDoTime, value);
        }

        public DaifaTradeExample.Criteria andLastDoTimeIn(List<Date> values) {
            return in(lastDoTime, values);
        }

        public DaifaTradeExample.Criteria andLastDoTimeNotIn(List<Date> values) {
            return notIn(lastDoTime, values);
        }

        public DaifaTradeExample.Criteria andLastDoTimeBetween(Date value1, Date value2) {
            return between(lastDoTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andLastDoTimeNotBetween(Date value1, Date value2) {
            return notBetween(lastDoTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andUseVoucherIsNull() {
            return isNull(useVoucher);
        }

        public DaifaTradeExample.Criteria andUseVoucherIsNotNull() {
            return isNotNull(useVoucher);
        }

        public DaifaTradeExample.Criteria andUseVoucherEqualTo(Integer value) {
            return equalTo(useVoucher, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherNotEqualTo(Integer value) {
            return notEqualTo(useVoucher, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherGreaterThan(Integer value) {
            return greaterThan(useVoucher, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(useVoucher, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherLessThan(Integer value) {
            return lessThan(useVoucher, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(useVoucher, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherIn(List<Integer> values) {
            return in(useVoucher, values);
        }

        public DaifaTradeExample.Criteria andUseVoucherNotIn(List<Integer> values) {
            return notIn(useVoucher, values);
        }

        public DaifaTradeExample.Criteria andUseVoucherBetween(Integer value1, Integer value2) {
            return between(useVoucher, value1, value2);
        }

        public DaifaTradeExample.Criteria andUseVoucherNotBetween(Integer value1, Integer value2) {
            return notBetween(useVoucher, value1, value2);
        }
        public DaifaTradeExample.Criteria andFinishTimeIsNull() {
            return isNull(finishTime);
        }

        public DaifaTradeExample.Criteria andFinishTimeIsNotNull() {
            return isNotNull(finishTime);
        }

        public DaifaTradeExample.Criteria andFinishTimeEqualTo(Date value) {
            return equalTo(finishTime, value);
        }

        public DaifaTradeExample.Criteria andFinishTimeNotEqualTo(Date value) {
            return notEqualTo(finishTime, value);
        }

        public DaifaTradeExample.Criteria andFinishTimeGreaterThan(Date value) {
            return greaterThan(finishTime, value);
        }

        public DaifaTradeExample.Criteria andFinishTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(finishTime, value);
        }

        public DaifaTradeExample.Criteria andFinishTimeLessThan(Date value) {
            return lessThan(finishTime, value);
        }

        public DaifaTradeExample.Criteria andFinishTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(finishTime, value);
        }

        public DaifaTradeExample.Criteria andFinishTimeIn(List<Date> values) {
            return in(finishTime, values);
        }

        public DaifaTradeExample.Criteria andFinishTimeNotIn(List<Date> values) {
            return notIn(finishTime, values);
        }

        public DaifaTradeExample.Criteria andFinishTimeBetween(Date value1, Date value2) {
            return between(finishTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andFinishTimeNotBetween(Date value1, Date value2) {
            return notBetween(finishTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andUseVoucherAmountIsNull() {
            return isNull(useVoucherAmount);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountIsNotNull() {
            return isNotNull(useVoucherAmount);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountEqualTo(String value) {
            return equalTo(useVoucherAmount, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountNotEqualTo(String value) {
            return notEqualTo(useVoucherAmount, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountGreaterThan(String value) {
            return greaterThan(useVoucherAmount, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(useVoucherAmount, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountLessThan(String value) {
            return lessThan(useVoucherAmount, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(useVoucherAmount, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountLike(String value) {
            return like(useVoucherAmount, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountNotLike(String value) {
            return notLike(useVoucherAmount, value);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountIn(List<String> values) {
            return in(useVoucherAmount, values);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountNotIn(List<String> values) {
            return notIn(useVoucherAmount, values);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountBetween(String value1, String value2) {
            return between(useVoucherAmount, value1, value2);
        }

        public DaifaTradeExample.Criteria andUseVoucherAmountNotBetween(String value1, String value2) {
            return notBetween(useVoucherAmount, value1, value2);
        }
        public DaifaTradeExample.Criteria andTuiFeeTimeIsNull() {
            return isNull(tuiFeeTime);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeIsNotNull() {
            return isNotNull(tuiFeeTime);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeEqualTo(Date value) {
            return equalTo(tuiFeeTime, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeNotEqualTo(Date value) {
            return notEqualTo(tuiFeeTime, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeGreaterThan(Date value) {
            return greaterThan(tuiFeeTime, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(tuiFeeTime, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeLessThan(Date value) {
            return lessThan(tuiFeeTime, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(tuiFeeTime, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeIn(List<Date> values) {
            return in(tuiFeeTime, values);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeNotIn(List<Date> values) {
            return notIn(tuiFeeTime, values);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeBetween(Date value1, Date value2) {
            return between(tuiFeeTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andTuiFeeTimeNotBetween(Date value1, Date value2) {
            return notBetween(tuiFeeTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andMoreTradeIdIsNull() {
            return isNull(moreTradeId);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdIsNotNull() {
            return isNotNull(moreTradeId);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdEqualTo(String value) {
            return equalTo(moreTradeId, value);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdNotEqualTo(String value) {
            return notEqualTo(moreTradeId, value);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdGreaterThan(String value) {
            return greaterThan(moreTradeId, value);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(moreTradeId, value);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdLessThan(String value) {
            return lessThan(moreTradeId, value);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(moreTradeId, value);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdLike(String value) {
            return like(moreTradeId, value);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdNotLike(String value) {
            return notLike(moreTradeId, value);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdIn(List<String> values) {
            return in(moreTradeId, values);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdNotIn(List<String> values) {
            return notIn(moreTradeId, values);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdBetween(String value1, String value2) {
            return between(moreTradeId, value1, value2);
        }

        public DaifaTradeExample.Criteria andMoreTradeIdNotBetween(String value1, String value2) {
            return notBetween(moreTradeId, value1, value2);
        }
        public DaifaTradeExample.Criteria andTradeCodeIsNull() {
            return isNull(tradeCode);
        }

        public DaifaTradeExample.Criteria andTradeCodeIsNotNull() {
            return isNotNull(tradeCode);
        }

        public DaifaTradeExample.Criteria andTradeCodeEqualTo(String value) {
            return equalTo(tradeCode, value);
        }

        public DaifaTradeExample.Criteria andTradeCodeNotEqualTo(String value) {
            return notEqualTo(tradeCode, value);
        }

        public DaifaTradeExample.Criteria andTradeCodeGreaterThan(String value) {
            return greaterThan(tradeCode, value);
        }

        public DaifaTradeExample.Criteria andTradeCodeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(tradeCode, value);
        }

        public DaifaTradeExample.Criteria andTradeCodeLessThan(String value) {
            return lessThan(tradeCode, value);
        }

        public DaifaTradeExample.Criteria andTradeCodeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(tradeCode, value);
        }

        public DaifaTradeExample.Criteria andTradeCodeLike(String value) {
            return like(tradeCode, value);
        }

        public DaifaTradeExample.Criteria andTradeCodeNotLike(String value) {
            return notLike(tradeCode, value);
        }

        public DaifaTradeExample.Criteria andTradeCodeIn(List<String> values) {
            return in(tradeCode, values);
        }

        public DaifaTradeExample.Criteria andTradeCodeNotIn(List<String> values) {
            return notIn(tradeCode, values);
        }

        public DaifaTradeExample.Criteria andTradeCodeBetween(String value1, String value2) {
            return between(tradeCode, value1, value2);
        }

        public DaifaTradeExample.Criteria andTradeCodeNotBetween(String value1, String value2) {
            return notBetween(tradeCode, value1, value2);
        }
        public DaifaTradeExample.Criteria andWeightIsNull() {
            return isNull(weight);
        }

        public DaifaTradeExample.Criteria andWeightIsNotNull() {
            return isNotNull(weight);
        }

        public DaifaTradeExample.Criteria andWeightEqualTo(String value) {
            return equalTo(weight, value);
        }

        public DaifaTradeExample.Criteria andWeightNotEqualTo(String value) {
            return notEqualTo(weight, value);
        }

        public DaifaTradeExample.Criteria andWeightGreaterThan(String value) {
            return greaterThan(weight, value);
        }

        public DaifaTradeExample.Criteria andWeightGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(weight, value);
        }

        public DaifaTradeExample.Criteria andWeightLessThan(String value) {
            return lessThan(weight, value);
        }

        public DaifaTradeExample.Criteria andWeightLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(weight, value);
        }

        public DaifaTradeExample.Criteria andWeightLike(String value) {
            return like(weight, value);
        }

        public DaifaTradeExample.Criteria andWeightNotLike(String value) {
            return notLike(weight, value);
        }

        public DaifaTradeExample.Criteria andWeightIn(List<String> values) {
            return in(weight, values);
        }

        public DaifaTradeExample.Criteria andWeightNotIn(List<String> values) {
            return notIn(weight, values);
        }

        public DaifaTradeExample.Criteria andWeightBetween(String value1, String value2) {
            return between(weight, value1, value2);
        }

        public DaifaTradeExample.Criteria andWeightNotBetween(String value1, String value2) {
            return notBetween(weight, value1, value2);
        }
        public DaifaTradeExample.Criteria andPostIdIsNull() {
            return isNull(postId);
        }

        public DaifaTradeExample.Criteria andPostIdIsNotNull() {
            return isNotNull(postId);
        }

        public DaifaTradeExample.Criteria andPostIdEqualTo(Long value) {
            return equalTo(postId, value);
        }

        public DaifaTradeExample.Criteria andPostIdNotEqualTo(Long value) {
            return notEqualTo(postId, value);
        }

        public DaifaTradeExample.Criteria andPostIdGreaterThan(Long value) {
            return greaterThan(postId, value);
        }

        public DaifaTradeExample.Criteria andPostIdGreaterThanOrEqualTo(Long value) {
            return greaterThanOrEqualTo(postId, value);
        }

        public DaifaTradeExample.Criteria andPostIdLessThan(Long value) {
            return lessThan(postId, value);
        }

        public DaifaTradeExample.Criteria andPostIdLessThanOrEqualTo(Long value) {
            return lessThanOrEqualTo(postId, value);
        }

        public DaifaTradeExample.Criteria andPostIdIn(List<Long> values) {
            return in(postId, values);
        }

        public DaifaTradeExample.Criteria andPostIdNotIn(List<Long> values) {
            return notIn(postId, values);
        }

        public DaifaTradeExample.Criteria andPostIdBetween(Long value1, Long value2) {
            return between(postId, value1, value2);
        }

        public DaifaTradeExample.Criteria andPostIdNotBetween(Long value1, Long value2) {
            return notBetween(postId, value1, value2);
        }
        public DaifaTradeExample.Criteria andDfTradeIdIsNull() {
            return isNull(dfTradeId);
        }

        public DaifaTradeExample.Criteria andDfTradeIdIsNotNull() {
            return isNotNull(dfTradeId);
        }

        public DaifaTradeExample.Criteria andDfTradeIdEqualTo(Long value) {
            return equalTo(dfTradeId, value);
        }

        public DaifaTradeExample.Criteria andDfTradeIdNotEqualTo(Long value) {
            return notEqualTo(dfTradeId, value);
        }

        public DaifaTradeExample.Criteria andDfTradeIdGreaterThan(Long value) {
            return greaterThan(dfTradeId, value);
        }

        public DaifaTradeExample.Criteria andDfTradeIdGreaterThanOrEqualTo(Long value) {
            return greaterThanOrEqualTo(dfTradeId, value);
        }

        public DaifaTradeExample.Criteria andDfTradeIdLessThan(Long value) {
            return lessThan(dfTradeId, value);
        }

        public DaifaTradeExample.Criteria andDfTradeIdLessThanOrEqualTo(Long value) {
            return lessThanOrEqualTo(dfTradeId, value);
        }

        public DaifaTradeExample.Criteria andDfTradeIdIn(List<Long> values) {
            return in(dfTradeId, values);
        }

        public DaifaTradeExample.Criteria andDfTradeIdNotIn(List<Long> values) {
            return notIn(dfTradeId, values);
        }

        public DaifaTradeExample.Criteria andDfTradeIdBetween(Long value1, Long value2) {
            return between(dfTradeId, value1, value2);
        }

        public DaifaTradeExample.Criteria andDfTradeIdNotBetween(Long value1, Long value2) {
            return notBetween(dfTradeId, value1, value2);
        }
        public DaifaTradeExample.Criteria andReceiverAddressIsNull() {
            return isNull(receiverAddress);
        }

        public DaifaTradeExample.Criteria andReceiverAddressIsNotNull() {
            return isNotNull(receiverAddress);
        }

        public DaifaTradeExample.Criteria andReceiverAddressEqualTo(String value) {
            return equalTo(receiverAddress, value);
        }

        public DaifaTradeExample.Criteria andReceiverAddressNotEqualTo(String value) {
            return notEqualTo(receiverAddress, value);
        }

        public DaifaTradeExample.Criteria andReceiverAddressGreaterThan(String value) {
            return greaterThan(receiverAddress, value);
        }

        public DaifaTradeExample.Criteria andReceiverAddressGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(receiverAddress, value);
        }

        public DaifaTradeExample.Criteria andReceiverAddressLessThan(String value) {
            return lessThan(receiverAddress, value);
        }

        public DaifaTradeExample.Criteria andReceiverAddressLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(receiverAddress, value);
        }

        public DaifaTradeExample.Criteria andReceiverAddressLike(String value) {
            return like(receiverAddress, value);
        }

        public DaifaTradeExample.Criteria andReceiverAddressNotLike(String value) {
            return notLike(receiverAddress, value);
        }

        public DaifaTradeExample.Criteria andReceiverAddressIn(List<String> values) {
            return in(receiverAddress, values);
        }

        public DaifaTradeExample.Criteria andReceiverAddressNotIn(List<String> values) {
            return notIn(receiverAddress, values);
        }

        public DaifaTradeExample.Criteria andReceiverAddressBetween(String value1, String value2) {
            return between(receiverAddress, value1, value2);
        }

        public DaifaTradeExample.Criteria andReceiverAddressNotBetween(String value1, String value2) {
            return notBetween(receiverAddress, value1, value2);
        }
        public DaifaTradeExample.Criteria andVolumeIsNull() {
            return isNull(volume);
        }

        public DaifaTradeExample.Criteria andVolumeIsNotNull() {
            return isNotNull(volume);
        }

        public DaifaTradeExample.Criteria andVolumeEqualTo(String value) {
            return equalTo(volume, value);
        }

        public DaifaTradeExample.Criteria andVolumeNotEqualTo(String value) {
            return notEqualTo(volume, value);
        }

        public DaifaTradeExample.Criteria andVolumeGreaterThan(String value) {
            return greaterThan(volume, value);
        }

        public DaifaTradeExample.Criteria andVolumeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(volume, value);
        }

        public DaifaTradeExample.Criteria andVolumeLessThan(String value) {
            return lessThan(volume, value);
        }

        public DaifaTradeExample.Criteria andVolumeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(volume, value);
        }

        public DaifaTradeExample.Criteria andVolumeLike(String value) {
            return like(volume, value);
        }

        public DaifaTradeExample.Criteria andVolumeNotLike(String value) {
            return notLike(volume, value);
        }

        public DaifaTradeExample.Criteria andVolumeIn(List<String> values) {
            return in(volume, values);
        }

        public DaifaTradeExample.Criteria andVolumeNotIn(List<String> values) {
            return notIn(volume, values);
        }

        public DaifaTradeExample.Criteria andVolumeBetween(String value1, String value2) {
            return between(volume, value1, value2);
        }

        public DaifaTradeExample.Criteria andVolumeNotBetween(String value1, String value2) {
            return notBetween(volume, value1, value2);
        }
        public DaifaTradeExample.Criteria andAgreeStoreServiceIsNull() {
            return isNull(agreeStoreService);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceIsNotNull() {
            return isNotNull(agreeStoreService);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceEqualTo(Integer value) {
            return equalTo(agreeStoreService, value);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceNotEqualTo(Integer value) {
            return notEqualTo(agreeStoreService, value);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceGreaterThan(Integer value) {
            return greaterThan(agreeStoreService, value);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(agreeStoreService, value);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceLessThan(Integer value) {
            return lessThan(agreeStoreService, value);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(agreeStoreService, value);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceIn(List<Integer> values) {
            return in(agreeStoreService, values);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceNotIn(List<Integer> values) {
            return notIn(agreeStoreService, values);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceBetween(Integer value1, Integer value2) {
            return between(agreeStoreService, value1, value2);
        }

        public DaifaTradeExample.Criteria andAgreeStoreServiceNotBetween(Integer value1, Integer value2) {
            return notBetween(agreeStoreService, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark9IsNull() {
            return isNull(remark9);
        }

        public DaifaTradeExample.Criteria andRemark9IsNotNull() {
            return isNotNull(remark9);
        }

        public DaifaTradeExample.Criteria andRemark9EqualTo(String value) {
            return equalTo(remark9, value);
        }

        public DaifaTradeExample.Criteria andRemark9NotEqualTo(String value) {
            return notEqualTo(remark9, value);
        }

        public DaifaTradeExample.Criteria andRemark9GreaterThan(String value) {
            return greaterThan(remark9, value);
        }

        public DaifaTradeExample.Criteria andRemark9GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark9, value);
        }

        public DaifaTradeExample.Criteria andRemark9LessThan(String value) {
            return lessThan(remark9, value);
        }

        public DaifaTradeExample.Criteria andRemark9LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark9, value);
        }

        public DaifaTradeExample.Criteria andRemark9Like(String value) {
            return like(remark9, value);
        }

        public DaifaTradeExample.Criteria andRemark9NotLike(String value) {
            return notLike(remark9, value);
        }

        public DaifaTradeExample.Criteria andRemark9In(List<String> values) {
            return in(remark9, values);
        }

        public DaifaTradeExample.Criteria andRemark9NotIn(List<String> values) {
            return notIn(remark9, values);
        }

        public DaifaTradeExample.Criteria andRemark9Between(String value1, String value2) {
            return between(remark9, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark9NotBetween(String value1, String value2) {
            return notBetween(remark9, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark8IsNull() {
            return isNull(remark8);
        }

        public DaifaTradeExample.Criteria andRemark8IsNotNull() {
            return isNotNull(remark8);
        }

        public DaifaTradeExample.Criteria andRemark8EqualTo(String value) {
            return equalTo(remark8, value);
        }

        public DaifaTradeExample.Criteria andRemark8NotEqualTo(String value) {
            return notEqualTo(remark8, value);
        }

        public DaifaTradeExample.Criteria andRemark8GreaterThan(String value) {
            return greaterThan(remark8, value);
        }

        public DaifaTradeExample.Criteria andRemark8GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark8, value);
        }

        public DaifaTradeExample.Criteria andRemark8LessThan(String value) {
            return lessThan(remark8, value);
        }

        public DaifaTradeExample.Criteria andRemark8LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark8, value);
        }

        public DaifaTradeExample.Criteria andRemark8Like(String value) {
            return like(remark8, value);
        }

        public DaifaTradeExample.Criteria andRemark8NotLike(String value) {
            return notLike(remark8, value);
        }

        public DaifaTradeExample.Criteria andRemark8In(List<String> values) {
            return in(remark8, values);
        }

        public DaifaTradeExample.Criteria andRemark8NotIn(List<String> values) {
            return notIn(remark8, values);
        }

        public DaifaTradeExample.Criteria andRemark8Between(String value1, String value2) {
            return between(remark8, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark8NotBetween(String value1, String value2) {
            return notBetween(remark8, value1, value2);
        }
        public DaifaTradeExample.Criteria andReturnGoodsStatusIsNull() {
            return isNull(returnGoodsStatus);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusIsNotNull() {
            return isNotNull(returnGoodsStatus);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusEqualTo(Integer value) {
            return equalTo(returnGoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusNotEqualTo(Integer value) {
            return notEqualTo(returnGoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusGreaterThan(Integer value) {
            return greaterThan(returnGoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(returnGoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusLessThan(Integer value) {
            return lessThan(returnGoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(returnGoodsStatus, value);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusIn(List<Integer> values) {
            return in(returnGoodsStatus, values);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusNotIn(List<Integer> values) {
            return notIn(returnGoodsStatus, values);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusBetween(Integer value1, Integer value2) {
            return between(returnGoodsStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andReturnGoodsStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(returnGoodsStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark5IsNull() {
            return isNull(remark5);
        }

        public DaifaTradeExample.Criteria andRemark5IsNotNull() {
            return isNotNull(remark5);
        }

        public DaifaTradeExample.Criteria andRemark5EqualTo(String value) {
            return equalTo(remark5, value);
        }

        public DaifaTradeExample.Criteria andRemark5NotEqualTo(String value) {
            return notEqualTo(remark5, value);
        }

        public DaifaTradeExample.Criteria andRemark5GreaterThan(String value) {
            return greaterThan(remark5, value);
        }

        public DaifaTradeExample.Criteria andRemark5GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark5, value);
        }

        public DaifaTradeExample.Criteria andRemark5LessThan(String value) {
            return lessThan(remark5, value);
        }

        public DaifaTradeExample.Criteria andRemark5LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark5, value);
        }

        public DaifaTradeExample.Criteria andRemark5Like(String value) {
            return like(remark5, value);
        }

        public DaifaTradeExample.Criteria andRemark5NotLike(String value) {
            return notLike(remark5, value);
        }

        public DaifaTradeExample.Criteria andRemark5In(List<String> values) {
            return in(remark5, values);
        }

        public DaifaTradeExample.Criteria andRemark5NotIn(List<String> values) {
            return notIn(remark5, values);
        }

        public DaifaTradeExample.Criteria andRemark5Between(String value1, String value2) {
            return between(remark5, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark5NotBetween(String value1, String value2) {
            return notBetween(remark5, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark4IsNull() {
            return isNull(remark4);
        }

        public DaifaTradeExample.Criteria andRemark4IsNotNull() {
            return isNotNull(remark4);
        }

        public DaifaTradeExample.Criteria andRemark4EqualTo(String value) {
            return equalTo(remark4, value);
        }

        public DaifaTradeExample.Criteria andRemark4NotEqualTo(String value) {
            return notEqualTo(remark4, value);
        }

        public DaifaTradeExample.Criteria andRemark4GreaterThan(String value) {
            return greaterThan(remark4, value);
        }

        public DaifaTradeExample.Criteria andRemark4GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark4, value);
        }

        public DaifaTradeExample.Criteria andRemark4LessThan(String value) {
            return lessThan(remark4, value);
        }

        public DaifaTradeExample.Criteria andRemark4LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark4, value);
        }

        public DaifaTradeExample.Criteria andRemark4Like(String value) {
            return like(remark4, value);
        }

        public DaifaTradeExample.Criteria andRemark4NotLike(String value) {
            return notLike(remark4, value);
        }

        public DaifaTradeExample.Criteria andRemark4In(List<String> values) {
            return in(remark4, values);
        }

        public DaifaTradeExample.Criteria andRemark4NotIn(List<String> values) {
            return notIn(remark4, values);
        }

        public DaifaTradeExample.Criteria andRemark4Between(String value1, String value2) {
            return between(remark4, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark4NotBetween(String value1, String value2) {
            return notBetween(remark4, value1, value2);
        }
        public DaifaTradeExample.Criteria andPostCodeIsNull() {
            return isNull(postCode);
        }

        public DaifaTradeExample.Criteria andPostCodeIsNotNull() {
            return isNotNull(postCode);
        }

        public DaifaTradeExample.Criteria andPostCodeEqualTo(String value) {
            return equalTo(postCode, value);
        }

        public DaifaTradeExample.Criteria andPostCodeNotEqualTo(String value) {
            return notEqualTo(postCode, value);
        }

        public DaifaTradeExample.Criteria andPostCodeGreaterThan(String value) {
            return greaterThan(postCode, value);
        }

        public DaifaTradeExample.Criteria andPostCodeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(postCode, value);
        }

        public DaifaTradeExample.Criteria andPostCodeLessThan(String value) {
            return lessThan(postCode, value);
        }

        public DaifaTradeExample.Criteria andPostCodeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(postCode, value);
        }

        public DaifaTradeExample.Criteria andPostCodeLike(String value) {
            return like(postCode, value);
        }

        public DaifaTradeExample.Criteria andPostCodeNotLike(String value) {
            return notLike(postCode, value);
        }

        public DaifaTradeExample.Criteria andPostCodeIn(List<String> values) {
            return in(postCode, values);
        }

        public DaifaTradeExample.Criteria andPostCodeNotIn(List<String> values) {
            return notIn(postCode, values);
        }

        public DaifaTradeExample.Criteria andPostCodeBetween(String value1, String value2) {
            return between(postCode, value1, value2);
        }

        public DaifaTradeExample.Criteria andPostCodeNotBetween(String value1, String value2) {
            return notBetween(postCode, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark7IsNull() {
            return isNull(remark7);
        }

        public DaifaTradeExample.Criteria andRemark7IsNotNull() {
            return isNotNull(remark7);
        }

        public DaifaTradeExample.Criteria andRemark7EqualTo(String value) {
            return equalTo(remark7, value);
        }

        public DaifaTradeExample.Criteria andRemark7NotEqualTo(String value) {
            return notEqualTo(remark7, value);
        }

        public DaifaTradeExample.Criteria andRemark7GreaterThan(String value) {
            return greaterThan(remark7, value);
        }

        public DaifaTradeExample.Criteria andRemark7GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark7, value);
        }

        public DaifaTradeExample.Criteria andRemark7LessThan(String value) {
            return lessThan(remark7, value);
        }

        public DaifaTradeExample.Criteria andRemark7LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark7, value);
        }

        public DaifaTradeExample.Criteria andRemark7Like(String value) {
            return like(remark7, value);
        }

        public DaifaTradeExample.Criteria andRemark7NotLike(String value) {
            return notLike(remark7, value);
        }

        public DaifaTradeExample.Criteria andRemark7In(List<String> values) {
            return in(remark7, values);
        }

        public DaifaTradeExample.Criteria andRemark7NotIn(List<String> values) {
            return notIn(remark7, values);
        }

        public DaifaTradeExample.Criteria andRemark7Between(String value1, String value2) {
            return between(remark7, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark7NotBetween(String value1, String value2) {
            return notBetween(remark7, value1, value2);
        }
        public DaifaTradeExample.Criteria andChangeStatusIsNull() {
            return isNull(changeStatus);
        }

        public DaifaTradeExample.Criteria andChangeStatusIsNotNull() {
            return isNotNull(changeStatus);
        }

        public DaifaTradeExample.Criteria andChangeStatusEqualTo(Integer value) {
            return equalTo(changeStatus, value);
        }

        public DaifaTradeExample.Criteria andChangeStatusNotEqualTo(Integer value) {
            return notEqualTo(changeStatus, value);
        }

        public DaifaTradeExample.Criteria andChangeStatusGreaterThan(Integer value) {
            return greaterThan(changeStatus, value);
        }

        public DaifaTradeExample.Criteria andChangeStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(changeStatus, value);
        }

        public DaifaTradeExample.Criteria andChangeStatusLessThan(Integer value) {
            return lessThan(changeStatus, value);
        }

        public DaifaTradeExample.Criteria andChangeStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(changeStatus, value);
        }

        public DaifaTradeExample.Criteria andChangeStatusIn(List<Integer> values) {
            return in(changeStatus, values);
        }

        public DaifaTradeExample.Criteria andChangeStatusNotIn(List<Integer> values) {
            return notIn(changeStatus, values);
        }

        public DaifaTradeExample.Criteria andChangeStatusBetween(Integer value1, Integer value2) {
            return between(changeStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andChangeStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(changeStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark6IsNull() {
            return isNull(remark6);
        }

        public DaifaTradeExample.Criteria andRemark6IsNotNull() {
            return isNotNull(remark6);
        }

        public DaifaTradeExample.Criteria andRemark6EqualTo(String value) {
            return equalTo(remark6, value);
        }

        public DaifaTradeExample.Criteria andRemark6NotEqualTo(String value) {
            return notEqualTo(remark6, value);
        }

        public DaifaTradeExample.Criteria andRemark6GreaterThan(String value) {
            return greaterThan(remark6, value);
        }

        public DaifaTradeExample.Criteria andRemark6GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark6, value);
        }

        public DaifaTradeExample.Criteria andRemark6LessThan(String value) {
            return lessThan(remark6, value);
        }

        public DaifaTradeExample.Criteria andRemark6LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark6, value);
        }

        public DaifaTradeExample.Criteria andRemark6Like(String value) {
            return like(remark6, value);
        }

        public DaifaTradeExample.Criteria andRemark6NotLike(String value) {
            return notLike(remark6, value);
        }

        public DaifaTradeExample.Criteria andRemark6In(List<String> values) {
            return in(remark6, values);
        }

        public DaifaTradeExample.Criteria andRemark6NotIn(List<String> values) {
            return notIn(remark6, values);
        }

        public DaifaTradeExample.Criteria andRemark6Between(String value1, String value2) {
            return between(remark6, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark6NotBetween(String value1, String value2) {
            return notBetween(remark6, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark1IsNull() {
            return isNull(remark1);
        }

        public DaifaTradeExample.Criteria andRemark1IsNotNull() {
            return isNotNull(remark1);
        }

        public DaifaTradeExample.Criteria andRemark1EqualTo(String value) {
            return equalTo(remark1, value);
        }

        public DaifaTradeExample.Criteria andRemark1NotEqualTo(String value) {
            return notEqualTo(remark1, value);
        }

        public DaifaTradeExample.Criteria andRemark1GreaterThan(String value) {
            return greaterThan(remark1, value);
        }

        public DaifaTradeExample.Criteria andRemark1GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark1, value);
        }

        public DaifaTradeExample.Criteria andRemark1LessThan(String value) {
            return lessThan(remark1, value);
        }

        public DaifaTradeExample.Criteria andRemark1LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark1, value);
        }

        public DaifaTradeExample.Criteria andRemark1Like(String value) {
            return like(remark1, value);
        }

        public DaifaTradeExample.Criteria andRemark1NotLike(String value) {
            return notLike(remark1, value);
        }

        public DaifaTradeExample.Criteria andRemark1In(List<String> values) {
            return in(remark1, values);
        }

        public DaifaTradeExample.Criteria andRemark1NotIn(List<String> values) {
            return notIn(remark1, values);
        }

        public DaifaTradeExample.Criteria andRemark1Between(String value1, String value2) {
            return between(remark1, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark1NotBetween(String value1, String value2) {
            return notBetween(remark1, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark3IsNull() {
            return isNull(remark3);
        }

        public DaifaTradeExample.Criteria andRemark3IsNotNull() {
            return isNotNull(remark3);
        }

        public DaifaTradeExample.Criteria andRemark3EqualTo(String value) {
            return equalTo(remark3, value);
        }

        public DaifaTradeExample.Criteria andRemark3NotEqualTo(String value) {
            return notEqualTo(remark3, value);
        }

        public DaifaTradeExample.Criteria andRemark3GreaterThan(String value) {
            return greaterThan(remark3, value);
        }

        public DaifaTradeExample.Criteria andRemark3GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark3, value);
        }

        public DaifaTradeExample.Criteria andRemark3LessThan(String value) {
            return lessThan(remark3, value);
        }

        public DaifaTradeExample.Criteria andRemark3LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark3, value);
        }

        public DaifaTradeExample.Criteria andRemark3Like(String value) {
            return like(remark3, value);
        }

        public DaifaTradeExample.Criteria andRemark3NotLike(String value) {
            return notLike(remark3, value);
        }

        public DaifaTradeExample.Criteria andRemark3In(List<String> values) {
            return in(remark3, values);
        }

        public DaifaTradeExample.Criteria andRemark3NotIn(List<String> values) {
            return notIn(remark3, values);
        }

        public DaifaTradeExample.Criteria andRemark3Between(String value1, String value2) {
            return between(remark3, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark3NotBetween(String value1, String value2) {
            return notBetween(remark3, value1, value2);
        }
        public DaifaTradeExample.Criteria andRemark2IsNull() {
            return isNull(remark2);
        }

        public DaifaTradeExample.Criteria andRemark2IsNotNull() {
            return isNotNull(remark2);
        }

        public DaifaTradeExample.Criteria andRemark2EqualTo(String value) {
            return equalTo(remark2, value);
        }

        public DaifaTradeExample.Criteria andRemark2NotEqualTo(String value) {
            return notEqualTo(remark2, value);
        }

        public DaifaTradeExample.Criteria andRemark2GreaterThan(String value) {
            return greaterThan(remark2, value);
        }

        public DaifaTradeExample.Criteria andRemark2GreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(remark2, value);
        }

        public DaifaTradeExample.Criteria andRemark2LessThan(String value) {
            return lessThan(remark2, value);
        }

        public DaifaTradeExample.Criteria andRemark2LessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(remark2, value);
        }

        public DaifaTradeExample.Criteria andRemark2Like(String value) {
            return like(remark2, value);
        }

        public DaifaTradeExample.Criteria andRemark2NotLike(String value) {
            return notLike(remark2, value);
        }

        public DaifaTradeExample.Criteria andRemark2In(List<String> values) {
            return in(remark2, values);
        }

        public DaifaTradeExample.Criteria andRemark2NotIn(List<String> values) {
            return notIn(remark2, values);
        }

        public DaifaTradeExample.Criteria andRemark2Between(String value1, String value2) {
            return between(remark2, value1, value2);
        }

        public DaifaTradeExample.Criteria andRemark2NotBetween(String value1, String value2) {
            return notBetween(remark2, value1, value2);
        }
        public DaifaTradeExample.Criteria andTuiFeeIsNull() {
            return isNull(tuiFee);
        }

        public DaifaTradeExample.Criteria andTuiFeeIsNotNull() {
            return isNotNull(tuiFee);
        }

        public DaifaTradeExample.Criteria andTuiFeeEqualTo(String value) {
            return equalTo(tuiFee, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeNotEqualTo(String value) {
            return notEqualTo(tuiFee, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeGreaterThan(String value) {
            return greaterThan(tuiFee, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(tuiFee, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeLessThan(String value) {
            return lessThan(tuiFee, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(tuiFee, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeLike(String value) {
            return like(tuiFee, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeNotLike(String value) {
            return notLike(tuiFee, value);
        }

        public DaifaTradeExample.Criteria andTuiFeeIn(List<String> values) {
            return in(tuiFee, values);
        }

        public DaifaTradeExample.Criteria andTuiFeeNotIn(List<String> values) {
            return notIn(tuiFee, values);
        }

        public DaifaTradeExample.Criteria andTuiFeeBetween(String value1, String value2) {
            return between(tuiFee, value1, value2);
        }

        public DaifaTradeExample.Criteria andTuiFeeNotBetween(String value1, String value2) {
            return notBetween(tuiFee, value1, value2);
        }
        public DaifaTradeExample.Criteria andStockoutStatusIsNull() {
            return isNull(stockoutStatus);
        }

        public DaifaTradeExample.Criteria andStockoutStatusIsNotNull() {
            return isNotNull(stockoutStatus);
        }

        public DaifaTradeExample.Criteria andStockoutStatusEqualTo(Integer value) {
            return equalTo(stockoutStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutStatusNotEqualTo(Integer value) {
            return notEqualTo(stockoutStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutStatusGreaterThan(Integer value) {
            return greaterThan(stockoutStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(stockoutStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutStatusLessThan(Integer value) {
            return lessThan(stockoutStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(stockoutStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutStatusIn(List<Integer> values) {
            return in(stockoutStatus, values);
        }

        public DaifaTradeExample.Criteria andStockoutStatusNotIn(List<Integer> values) {
            return notIn(stockoutStatus, values);
        }

        public DaifaTradeExample.Criteria andStockoutStatusBetween(Integer value1, Integer value2) {
            return between(stockoutStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andStockoutStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(stockoutStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andPayNoIsNull() {
            return isNull(payNo);
        }

        public DaifaTradeExample.Criteria andPayNoIsNotNull() {
            return isNotNull(payNo);
        }

        public DaifaTradeExample.Criteria andPayNoEqualTo(String value) {
            return equalTo(payNo, value);
        }

        public DaifaTradeExample.Criteria andPayNoNotEqualTo(String value) {
            return notEqualTo(payNo, value);
        }

        public DaifaTradeExample.Criteria andPayNoGreaterThan(String value) {
            return greaterThan(payNo, value);
        }

        public DaifaTradeExample.Criteria andPayNoGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(payNo, value);
        }

        public DaifaTradeExample.Criteria andPayNoLessThan(String value) {
            return lessThan(payNo, value);
        }

        public DaifaTradeExample.Criteria andPayNoLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(payNo, value);
        }

        public DaifaTradeExample.Criteria andPayNoLike(String value) {
            return like(payNo, value);
        }

        public DaifaTradeExample.Criteria andPayNoNotLike(String value) {
            return notLike(payNo, value);
        }

        public DaifaTradeExample.Criteria andPayNoIn(List<String> values) {
            return in(payNo, values);
        }

        public DaifaTradeExample.Criteria andPayNoNotIn(List<String> values) {
            return notIn(payNo, values);
        }

        public DaifaTradeExample.Criteria andPayNoBetween(String value1, String value2) {
            return between(payNo, value1, value2);
        }

        public DaifaTradeExample.Criteria andPayNoNotBetween(String value1, String value2) {
            return notBetween(payNo, value1, value2);
        }
        public DaifaTradeExample.Criteria andZdPostFeeBuTimeIsNull() {
            return isNull(zdPostFeeBuTime);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeIsNotNull() {
            return isNotNull(zdPostFeeBuTime);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeEqualTo(Date value) {
            return equalTo(zdPostFeeBuTime, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeNotEqualTo(Date value) {
            return notEqualTo(zdPostFeeBuTime, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeGreaterThan(Date value) {
            return greaterThan(zdPostFeeBuTime, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(zdPostFeeBuTime, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeLessThan(Date value) {
            return lessThan(zdPostFeeBuTime, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(zdPostFeeBuTime, value);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeIn(List<Date> values) {
            return in(zdPostFeeBuTime, values);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeNotIn(List<Date> values) {
            return notIn(zdPostFeeBuTime, values);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeBetween(Date value1, Date value2) {
            return between(zdPostFeeBuTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andZdPostFeeBuTimeNotBetween(Date value1, Date value2) {
            return notBetween(zdPostFeeBuTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andOutOfStockTimeIsNull() {
            return isNull(outOfStockTime);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeIsNotNull() {
            return isNotNull(outOfStockTime);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeEqualTo(Date value) {
            return equalTo(outOfStockTime, value);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeNotEqualTo(Date value) {
            return notEqualTo(outOfStockTime, value);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeGreaterThan(Date value) {
            return greaterThan(outOfStockTime, value);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeGreaterThanOrEqualTo(Date value) {
            return greaterThanOrEqualTo(outOfStockTime, value);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeLessThan(Date value) {
            return lessThan(outOfStockTime, value);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeLessThanOrEqualTo(Date value) {
            return lessThanOrEqualTo(outOfStockTime, value);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeIn(List<Date> values) {
            return in(outOfStockTime, values);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeNotIn(List<Date> values) {
            return notIn(outOfStockTime, values);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeBetween(Date value1, Date value2) {
            return between(outOfStockTime, value1, value2);
        }

        public DaifaTradeExample.Criteria andOutOfStockTimeNotBetween(Date value1, Date value2) {
            return notBetween(outOfStockTime, value1, value2);
        }
        public DaifaTradeExample.Criteria andOrderQrcodeIsNull() {
            return isNull(orderQrcode);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeIsNotNull() {
            return isNotNull(orderQrcode);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeEqualTo(String value) {
            return equalTo(orderQrcode, value);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeNotEqualTo(String value) {
            return notEqualTo(orderQrcode, value);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeGreaterThan(String value) {
            return greaterThan(orderQrcode, value);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(orderQrcode, value);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeLessThan(String value) {
            return lessThan(orderQrcode, value);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(orderQrcode, value);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeLike(String value) {
            return like(orderQrcode, value);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeNotLike(String value) {
            return notLike(orderQrcode, value);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeIn(List<String> values) {
            return in(orderQrcode, values);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeNotIn(List<String> values) {
            return notIn(orderQrcode, values);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeBetween(String value1, String value2) {
            return between(orderQrcode, value1, value2);
        }

        public DaifaTradeExample.Criteria andOrderQrcodeNotBetween(String value1, String value2) {
            return notBetween(orderQrcode, value1, value2);
        }
        public DaifaTradeExample.Criteria andGoodsNumIsNull() {
            return isNull(goodsNum);
        }

        public DaifaTradeExample.Criteria andGoodsNumIsNotNull() {
            return isNotNull(goodsNum);
        }

        public DaifaTradeExample.Criteria andGoodsNumEqualTo(Integer value) {
            return equalTo(goodsNum, value);
        }

        public DaifaTradeExample.Criteria andGoodsNumNotEqualTo(Integer value) {
            return notEqualTo(goodsNum, value);
        }

        public DaifaTradeExample.Criteria andGoodsNumGreaterThan(Integer value) {
            return greaterThan(goodsNum, value);
        }

        public DaifaTradeExample.Criteria andGoodsNumGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(goodsNum, value);
        }

        public DaifaTradeExample.Criteria andGoodsNumLessThan(Integer value) {
            return lessThan(goodsNum, value);
        }

        public DaifaTradeExample.Criteria andGoodsNumLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(goodsNum, value);
        }

        public DaifaTradeExample.Criteria andGoodsNumIn(List<Integer> values) {
            return in(goodsNum, values);
        }

        public DaifaTradeExample.Criteria andGoodsNumNotIn(List<Integer> values) {
            return notIn(goodsNum, values);
        }

        public DaifaTradeExample.Criteria andGoodsNumBetween(Integer value1, Integer value2) {
            return between(goodsNum, value1, value2);
        }

        public DaifaTradeExample.Criteria andGoodsNumNotBetween(Integer value1, Integer value2) {
            return notBetween(goodsNum, value1, value2);
        }
        public DaifaTradeExample.Criteria andTbWriteLabelStatusIsNull() {
            return isNull(tbWriteLabelStatus);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusIsNotNull() {
            return isNotNull(tbWriteLabelStatus);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusEqualTo(Integer value) {
            return equalTo(tbWriteLabelStatus, value);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusNotEqualTo(Integer value) {
            return notEqualTo(tbWriteLabelStatus, value);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusGreaterThan(Integer value) {
            return greaterThan(tbWriteLabelStatus, value);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(tbWriteLabelStatus, value);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusLessThan(Integer value) {
            return lessThan(tbWriteLabelStatus, value);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(tbWriteLabelStatus, value);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusIn(List<Integer> values) {
            return in(tbWriteLabelStatus, values);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusNotIn(List<Integer> values) {
            return notIn(tbWriteLabelStatus, values);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusBetween(Integer value1, Integer value2) {
            return between(tbWriteLabelStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andTbWriteLabelStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(tbWriteLabelStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andPrintExpressStatusIsNull() {
            return isNull(printExpressStatus);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusIsNotNull() {
            return isNotNull(printExpressStatus);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusEqualTo(Integer value) {
            return equalTo(printExpressStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusNotEqualTo(Integer value) {
            return notEqualTo(printExpressStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusGreaterThan(Integer value) {
            return greaterThan(printExpressStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(printExpressStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusLessThan(Integer value) {
            return lessThan(printExpressStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(printExpressStatus, value);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusIn(List<Integer> values) {
            return in(printExpressStatus, values);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusNotIn(List<Integer> values) {
            return notIn(printExpressStatus, values);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusBetween(Integer value1, Integer value2) {
            return between(printExpressStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andPrintExpressStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(printExpressStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andStockoutCycleStatusIsNull() {
            return isNull(stockoutCycleStatus);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusIsNotNull() {
            return isNotNull(stockoutCycleStatus);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusEqualTo(Integer value) {
            return equalTo(stockoutCycleStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusNotEqualTo(Integer value) {
            return notEqualTo(stockoutCycleStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusGreaterThan(Integer value) {
            return greaterThan(stockoutCycleStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(stockoutCycleStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusLessThan(Integer value) {
            return lessThan(stockoutCycleStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(stockoutCycleStatus, value);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusIn(List<Integer> values) {
            return in(stockoutCycleStatus, values);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusNotIn(List<Integer> values) {
            return notIn(stockoutCycleStatus, values);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusBetween(Integer value1, Integer value2) {
            return between(stockoutCycleStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andStockoutCycleStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(stockoutCycleStatus, value1, value2);
        }
        public DaifaTradeExample.Criteria andReceiverNameIsNull() {
            return isNull(receiverName);
        }

        public DaifaTradeExample.Criteria andReceiverNameIsNotNull() {
            return isNotNull(receiverName);
        }

        public DaifaTradeExample.Criteria andReceiverNameEqualTo(String value) {
            return equalTo(receiverName, value);
        }

        public DaifaTradeExample.Criteria andReceiverNameNotEqualTo(String value) {
            return notEqualTo(receiverName, value);
        }

        public DaifaTradeExample.Criteria andReceiverNameGreaterThan(String value) {
            return greaterThan(receiverName, value);
        }

        public DaifaTradeExample.Criteria andReceiverNameGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(receiverName, value);
        }

        public DaifaTradeExample.Criteria andReceiverNameLessThan(String value) {
            return lessThan(receiverName, value);
        }

        public DaifaTradeExample.Criteria andReceiverNameLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(receiverName, value);
        }

        public DaifaTradeExample.Criteria andReceiverNameLike(String value) {
            return like(receiverName, value);
        }

        public DaifaTradeExample.Criteria andReceiverNameNotLike(String value) {
            return notLike(receiverName, value);
        }

        public DaifaTradeExample.Criteria andReceiverNameIn(List<String> values) {
            return in(receiverName, values);
        }

        public DaifaTradeExample.Criteria andReceiverNameNotIn(List<String> values) {
            return notIn(receiverName, values);
        }

        public DaifaTradeExample.Criteria andReceiverNameBetween(String value1, String value2) {
            return between(receiverName, value1, value2);
        }

        public DaifaTradeExample.Criteria andReceiverNameNotBetween(String value1, String value2) {
            return notBetween(receiverName, value1, value2);
        }
        public DaifaTradeExample.Criteria andRefundReasonIsNull() {
            return isNull(refundReason);
        }

        public DaifaTradeExample.Criteria andRefundReasonIsNotNull() {
            return isNotNull(refundReason);
        }

        public DaifaTradeExample.Criteria andRefundReasonEqualTo(String value) {
            return equalTo(refundReason, value);
        }

        public DaifaTradeExample.Criteria andRefundReasonNotEqualTo(String value) {
            return notEqualTo(refundReason, value);
        }

        public DaifaTradeExample.Criteria andRefundReasonGreaterThan(String value) {
            return greaterThan(refundReason, value);
        }

        public DaifaTradeExample.Criteria andRefundReasonGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(refundReason, value);
        }

        public DaifaTradeExample.Criteria andRefundReasonLessThan(String value) {
            return lessThan(refundReason, value);
        }

        public DaifaTradeExample.Criteria andRefundReasonLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(refundReason, value);
        }

        public DaifaTradeExample.Criteria andRefundReasonLike(String value) {
            return like(refundReason, value);
        }

        public DaifaTradeExample.Criteria andRefundReasonNotLike(String value) {
            return notLike(refundReason, value);
        }

        public DaifaTradeExample.Criteria andRefundReasonIn(List<String> values) {
            return in(refundReason, values);
        }

        public DaifaTradeExample.Criteria andRefundReasonNotIn(List<String> values) {
            return notIn(refundReason, values);
        }

        public DaifaTradeExample.Criteria andRefundReasonBetween(String value1, String value2) {
            return between(refundReason, value1, value2);
        }

        public DaifaTradeExample.Criteria andRefundReasonNotBetween(String value1, String value2) {
            return notBetween(refundReason, value1, value2);
        }
        public DaifaTradeExample.Criteria andMoneyIsNull() {
            return isNull(money);
        }

        public DaifaTradeExample.Criteria andMoneyIsNotNull() {
            return isNotNull(money);
        }

        public DaifaTradeExample.Criteria andMoneyEqualTo(String value) {
            return equalTo(money, value);
        }

        public DaifaTradeExample.Criteria andMoneyNotEqualTo(String value) {
            return notEqualTo(money, value);
        }

        public DaifaTradeExample.Criteria andMoneyGreaterThan(String value) {
            return greaterThan(money, value);
        }

        public DaifaTradeExample.Criteria andMoneyGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(money, value);
        }

        public DaifaTradeExample.Criteria andMoneyLessThan(String value) {
            return lessThan(money, value);
        }

        public DaifaTradeExample.Criteria andMoneyLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(money, value);
        }

        public DaifaTradeExample.Criteria andMoneyLike(String value) {
            return like(money, value);
        }

        public DaifaTradeExample.Criteria andMoneyNotLike(String value) {
            return notLike(money, value);
        }

        public DaifaTradeExample.Criteria andMoneyIn(List<String> values) {
            return in(money, values);
        }

        public DaifaTradeExample.Criteria andMoneyNotIn(List<String> values) {
            return notIn(money, values);
        }

        public DaifaTradeExample.Criteria andMoneyBetween(String value1, String value2) {
            return between(money, value1, value2);
        }

        public DaifaTradeExample.Criteria andMoneyNotBetween(String value1, String value2) {
            return notBetween(money, value1, value2);
        }
        public DaifaTradeExample.Criteria andTotalFeeIsNull() {
            return isNull(totalFee);
        }

        public DaifaTradeExample.Criteria andTotalFeeIsNotNull() {
            return isNotNull(totalFee);
        }

        public DaifaTradeExample.Criteria andTotalFeeEqualTo(String value) {
            return equalTo(totalFee, value);
        }

        public DaifaTradeExample.Criteria andTotalFeeNotEqualTo(String value) {
            return notEqualTo(totalFee, value);
        }

        public DaifaTradeExample.Criteria andTotalFeeGreaterThan(String value) {
            return greaterThan(totalFee, value);
        }

        public DaifaTradeExample.Criteria andTotalFeeGreaterThanOrEqualTo(String value) {
            return greaterThanOrEqualTo(totalFee, value);
        }

        public DaifaTradeExample.Criteria andTotalFeeLessThan(String value) {
            return lessThan(totalFee, value);
        }

        public DaifaTradeExample.Criteria andTotalFeeLessThanOrEqualTo(String value) {
            return lessThanOrEqualTo(totalFee, value);
        }

        public DaifaTradeExample.Criteria andTotalFeeLike(String value) {
            return like(totalFee, value);
        }

        public DaifaTradeExample.Criteria andTotalFeeNotLike(String value) {
            return notLike(totalFee, value);
        }

        public DaifaTradeExample.Criteria andTotalFeeIn(List<String> values) {
            return in(totalFee, values);
        }

        public DaifaTradeExample.Criteria andTotalFeeNotIn(List<String> values) {
            return notIn(totalFee, values);
        }

        public DaifaTradeExample.Criteria andTotalFeeBetween(String value1, String value2) {
            return between(totalFee, value1, value2);
        }

        public DaifaTradeExample.Criteria andTotalFeeNotBetween(String value1, String value2) {
            return notBetween(totalFee, value1, value2);
        }
        public DaifaTradeExample.Criteria andPayStatusIsNull() {
            return isNull(payStatus);
        }

        public DaifaTradeExample.Criteria andPayStatusIsNotNull() {
            return isNotNull(payStatus);
        }

        public DaifaTradeExample.Criteria andPayStatusEqualTo(Integer value) {
            return equalTo(payStatus, value);
        }

        public DaifaTradeExample.Criteria andPayStatusNotEqualTo(Integer value) {
            return notEqualTo(payStatus, value);
        }

        public DaifaTradeExample.Criteria andPayStatusGreaterThan(Integer value) {
            return greaterThan(payStatus, value);
        }

        public DaifaTradeExample.Criteria andPayStatusGreaterThanOrEqualTo(Integer value) {
            return greaterThanOrEqualTo(payStatus, value);
        }

        public DaifaTradeExample.Criteria andPayStatusLessThan(Integer value) {
            return lessThan(payStatus, value);
        }

        public DaifaTradeExample.Criteria andPayStatusLessThanOrEqualTo(Integer value) {
            return lessThanOrEqualTo(payStatus, value);
        }

        public DaifaTradeExample.Criteria andPayStatusIn(List<Integer> values) {
            return in(payStatus, values);
        }

        public DaifaTradeExample.Criteria andPayStatusNotIn(List<Integer> values) {
            return notIn(payStatus, values);
        }

        public DaifaTradeExample.Criteria andPayStatusBetween(Integer value1, Integer value2) {
            return between(payStatus, value1, value2);
        }

        public DaifaTradeExample.Criteria andPayStatusNotBetween(Integer value1, Integer value2) {
            return notBetween(payStatus, value1, value2);
        }
    }
}